From e7f82ac9e7f9920f624e1ea75b8ab7ec375a141a Mon Sep 17 00:00:00 2001 From: Greg Date: Wed, 4 Dec 2019 17:06:14 -0500 Subject: [PATCH 1/2] Working Android version using Blessed library. --- Ble.jar | Bin 7223 -> 6983 bytes BleConnect.java | 267 -------------------------------------------- BlessedConnect.java | 46 ++++---- ble_android.go | 34 +++--- blessed-full.jar | Bin 78708 -> 78587 bytes 5 files changed, 36 insertions(+), 311 deletions(-) delete mode 100644 BleConnect.java diff --git a/Ble.jar b/Ble.jar index 49dd545430ae644ef086a872dd9b5867af274da7..88c38961337640615dbe5231e0c174a66976ec08 100644 GIT binary patch delta 5979 zcmY*dWl$VSwsD1cxAtJ3)eOaMut#xU)gBxcdUZ3GNB*t_#84B}gE+JG`4) z@2mH|nX2yUshO(zaZcB%ZV(*c$5Mr$yd*+GM@L5@kBr9>LH-97g8t$d&0jpB`v>8m z7fgRi{KcEUR1N^c(_aw4UL$L(wY~yH77}5tXQoSl%84|cTBGjh=xtlbtKTOKx!y{f zyY&N3awx}=O>z!R?28s^exGG>{ytcEx_f+N@-u)=g!3T&?Dm9(7!u?O6DU$@>|;|A z_b2h@m=OrfTqVaWHRkp78ew1aF6;bC4Eco3Lv9IAftY6H(6L6sz&xX1T`W3Vxg%W$ ze7$t)24XSlkmV7`+HYlErSCl5BomZ9aksc@2au3=#?2WyMa(|!+6#+YU6|>HWTT4D zIp|ckseonQev~Ss9sfhF@)Q|42R)HxLc<)^cT(R^*h8~YG3lgEKCTm?C7;Av zTvF!-L<+QjF)_4yV-2e>DUS6Sfajb*%0yWq0^z7AR?edmZ;8nkAyV8K8tute_YAgl zK!j%%t>{;PWT)^9vuPF$ihcqt4!tLyC3Vu0)us@BSMXo1x~o?#a;B!%7F z@}k*tf1$yhO0lfod$*zhf^X1S=$76H0GvAwCiEu>Zi5*#gM>8>OEiGF#HBh-i8+#S zmWsunj7`{cPMNbWA8%jamWuNd6n}X_QiTA} z$1$k|c~Fp$i~vag=>KcHe_M(cl^lkdLbR1joXJvWV+9=5MYDR?%wV)q1n-!*0NW#C zyKv)ALvh!og&d@uiSXcqM_D6TD~^tDzkIpJF~Lx|i|eDJ(&0+$(nZ@8W(1d*0X_M) zcv5Daae2syOtsVo?1ybqrkt{KbPl0v?Y-dDuteWixCiw`2g#fV?jPR8JHg7h(S!1a z%$s*mv%H4DS~s!w&grj>lD?aeT0{Nk4}7e{og(2Z(%D$Xm~zm2dQK3zsFUrw04y0_6+FAWbVInnE1J#`&jx-CB0gfaT-H{53dS0Sn* zlQSk{q!Oc@uk1oJm*7~IB(M~b2_S0^wC0t~va^nKk=YM5jd`MEx+4`s+J{D$78d6+hp8bTlrks+{CFIxnG~13%yWVs zi=9{{8{JY%a*K+Vr);WwDYQoyGFX#j^j4`pU3`P4ZJK4K4Db52C+ts2p6Hqbf*-|| z%n}&gxLZFKSihqA8r0@vtWnMrWw>lko=~rvl&^{<9sKKdiRhs`hEdb!z$sgu@`Z}ga zpBJvW20fXPhAMoU4-e;^urRNb`mGf;fo{m81hk7nME9OBI^e5J1)!XBkw+xUoIN1_ ztv<+=gR?a<5)%8%|E|6u6{P=N@Ol6{tU~)==DERkW4mV;Wm zXuFim4Da@1pWmaNN26=c56&c=aHuT>0d%$(U({;7)&B)yASt&~S7)VvBwCgLEWQtu z(fHkHFS@K!Mh^qkS0!E+1mutRdm~xwD2hf?Q)D3&9qbHsgaXQ(+xyhUm`^gkJ)J+% zjJZxqW9Hn3t*ztEMdh=`$CEM5EoI8hcN&L>8`*f)t6!PiN^X1}j`vMm924Uh`y`mQ zNGss0CB5nuql2j`xZ4r+f7c1I3(xO>nY~q$^ztq5pKH4m9w*-cck0fjpQQ zUeL;}FdS_IQNi7^<2=U9Dyp?^N`y`%SGP)h&<t<>ec3(5knAxex^Ao=`?5Ud8uBJVBu@Ma% zv}!VgaEN+EB!FlJE^RCxzJ^w1Dhdh69TXtKT1o`Zzc%#*yrvd3O}))=?w9HEoCoU& zwG3tY`g9rB4|bD?4uD>e!5o4HKgZ8)=n6&*u+vLo)wvp43##LY!RNQ`HT3~C;7Fmg zV!)0pqe=lEJxzvYZJVM9Wp*K&BzqC-*G*aJlJthos&AWxs3eiXqL|2-#K|YkA-*ELKHr*$E7XvYBp;Pg;!IZAO`I72YJF7!3 zc4Vb=Dj1O&3DxO^gXZE>Kwok*S^2;A8mH-fv!i-LyxLhBEHLxr>Cnd~VnDlJvD^h9 z)prL|P`M1SswEw1P)uBn*YGVsYSIe~VB>Wx%3fZjIZeq)NC!18RY7wY{PV^Mo4t zE+o09w3mCOu`ujt(fLZ3`K3Yjv0Wwgskxt)MU8UUyue6)nBKNq)WzQN&d12Tki~Jq zwtM>B8Nhg2`pl_<=hEKWaF6lU@fEe{aR6APPEiJjYcoqxMOsJSpM=4>hN z!JfU2-F?3}o2?*yqnj0r9GZ5mD=$sCWgpNg9sgZ7j2iGc_SLaQz6h~tucY`ZL@3c- z*D3mBsMj45EEK(3NwRs?jA#|>~7?(}1Dphg{$HRXqa9CymB2atlkb+mzXe(*p9s%>`wAe{6j3*p$+Z9jR1 z(l+!Q_VFQTs#ZOA@#;~yM3B%ntzPiMwB>!ToK&Ak^m|1m~(6ZG_m`PU;m zgoxkGpZsHxPFVkKk_k8hFbt^X4Cu*`8!nLAD#48hwhO^C;f9+dTWjXZlOjh2z2sp- ztG(d*Oiu?-6+B0t9O0NPh}3T}6|f znEFz_eQf96WzA^xaSV1WbiM5QyX$$?3$IflcR3vBBTc-P*wG|k%U1u=&UR#)b4WJRsDI}j`y~!cm)QF}LIxz!$`PJ)S$fWk&bG-=YpjtWLPm!4t zl`VAYx}3jGg0oCp_6SS>UMbX}0Ix*U!VMV4Uo5z$vpIOKe@kqY?#fiw-2AGX;nzah zXn?ayCwG*ThBLSW^L2T8tZp3e2W(wS0={hbN<(#tJ2<-Optb0+8_s&7IqM1wkBNlQ zH_?P0eaG~Osp{LP0IN*vgcT4}S@F@BcueFZ0EJWd1hDWd2QYS7R{y6O-1Vt?_L$+Q#Q^=Ujsc+pEfp`2#aCU-4W6J@u5Zw0^gBLy){#Yv0lj z8QS!^aczHCn%ap9gs^j_Y@nxYuaL-^gB9`Mk>rm@SEsMaOVXIJA^t_ok8; z8`y+gvrps9m1*&jq@#}U;B&yz{9&f4ae|BboZk?# ztq}e0p(<-N%whaD>k2zYPlH(f${dJ)i(FyZu;}eJRpGDP_EqJP@xAXZ5hGM_nW$CP zL#Rv3J(oDg7*Sm!duLCzu36$X6j&N8If|cQULjuB))=vUt||zd!OOKWaZL-eY@vXq zufZV~YP5?CdCCK!Qhah7{S1W-f^~Q(klfPtcJZYYfkrNvlbQbldjH+8*S>nXXagA1 zkJZX&>dvU&HJ!;gbeu6bw4Axbe@OLMf+Wk;s)+YB-TeNjh!(EIeL#nHwnA2KZDtDbXP^~^&s8MhXyXd0y0Eu=!C%z}&kN9{qCVr5A5%!Do$y?Ym*l5Lv6tqyM;hodp;^(OYJ1nX+A0dSQ# zC2h7^F*2k9jHY#I8Gxt6*T^MM@n#98H@9^y00>M^M%7OjsH?qAp9M#&o^n2|ZW2cpYG2|`oRV`=!MJ*p~@*A<%v6F-a6cEk&NtI{Z&za_n#)#)%VXS`O zo{u}S9y(=VlPf`ZpIK=qPn+?zWyJZZA|rxW|#I2i07KUic`M0 zCuXRdWPDDzi*o9nlZxcZ8}fK*Ei)1pzY~Oi_R_yK`u#R!a-1cKG&c8Dd{bUCX(@&( ze?UIgGlO$mWYh)JoAG{4P*jLI>xqVeN-?;-|4*I;Bv3m6N5{~!*Z_uWkNqc}y$pa_ zhEE013gbp9&m=j(z0O|zL!lQ7U+NpP(N}zO9r}W0;0$Z!4nsrViH*W69&(LzPNds* zJ>p2KDPae%5)h~+(+oB^Ja9D(r?-r?0SXA4_Y>@6rH^XTU$1(-bLMlfh4V0}x0m*$ z1`2*cK=1t2W%p(YDhf;N)y{b)e6d{J`xUr#7+t@EhRP2yJ$EMcTKFq#o#hd6Vp~?d zlMR(+Z>~ST<2zq58xg#nXW5ee>7##&-C|OXL{TbW!pJ&~CIQ=c>*$JjTL@)?m?s1L zFVB9XX7qRre7izxG*=&JhFIF~eEme$v7Pv_5W(F$8(dk1#&&fOxB_2`MUJhYi5OVL z4gHM-6q!Fhki*|EEho7)quk%LXv?Q5;P`6Wjl}qU?G5Zvg6XFav$;@YBhM?C9Qgp> z`%a$>`50rn0Tx(scWR2#Cq_Tw$e(HwqY{w=Ew~oF8T4FjSq7?ZNN^Fu?Rzjoc*%a- z_dSK-`Ed2vLywI4_~SI{S_Uq75UWW3g-rC(o3M`lvQ|N>T9C?kpLmza%&4kGaPBdc&+8!R zVP#lLP#FPRorzE{XN0y4&W5zA?~zPknS+8b_T)c~j1jn`B^yAn_I$Z6^m(*hNVX6} z$G(+^+l$00wwrFBN+#)*htA~L{|NtS%c`SjH1OUn5-6-NW!gd|GkMFTV4_2QV?L#q zV2wa+4fpfbYf1If41enKJH=X;IY{`0sU(4%SzQXVe5(wyu2_kkdg+mykQ9vUnd_Vr zy;<~iYJXJTRISM#$?8b_%uf3h>pUMv_4JD=_4?7W?1zrbb`QLw4IFqUbZZGW@Uy*? z|0(rOf-FtFp85B!TI4S%tJ11A^sj{%Ob3I4h!=2mr@WDM$C#Cm{S zdg)O}9c1pe*R=HXDcD`KyG}gqiaGQmh3Y0Hct)N+T+8O;!ud7Sw(-YE6JXCdK&&g; zhZTk1=ydZY2-S_RpkR`}xtn_rsBzd*nHUY*uI4&KBjZ*{N|C!^q9Q2i@QNs}^r<#s zG8AR=Utu;q*4qn97GTa5Qz9Q5kI#}J%QEYQW_{xXC$u4YZn($B-Y|-ZobCT4;=ZRB zw>b4q028c>(*EGRUGT_RnKdahvgT}{v13L!stzSq2iS5|EE^Y2^9c@7er{1sS?h!~ zsza-2J!n3c40~W}j()JS3*pWDo`Rfc`@m2d~68i=^A1n1YHIN3c^$*$! zoV{)$Js$sa%o66<*Pq1q$b)i*fXkhOl?+_uy6Vk z_iTk<^0~q~MoC$$=7+_SVWpSswe3@+P7boS&;JHy;JwBTeM}^zRkDAkacsy7WFn;h zgw^mUGNHd|^Z=Q}U&0{g{7b^*Jb%fNT;MMilZ#-GM+T|8kDP&&#J^KG2p!-iu@-J^<{qvTASQUbb_E!V{*?Iqj KD>0;h)&Bt4sxrv{ delta 6249 zcmY*-1ymHkxBdc4!y>RCCB5{LD-9yu-67H;CEW`MNY~QcO9=}|NaNC7(ug1}DJlpE zPk-OoXNqNnrl9Dv|%}G{Zl8 z&hpnHC@|Rnfiwp9Kezz$Bl0lF-~!Bs&$}2Y;w!;K+XZQ-CJo`^t9$g>dDoG%-h(vH1tmXbp!as2%1WmI=cX3fJaVAA5LjypI}u? zrMQ^1-l)plBrN4N86-*cAup?Ey1+5b92v=1N*(?DlA&jXI9mQiNB)+J&UJ7_Q_JWZ zpFDHwz={X`$fUaotka(D@MYf1zF$$NGEnT-5d?eyydG$~y-iOW4k zIfYFJtR@@(7|&nqJK~v zVy#D-5YH^xLOiY`vlZtpKn2hlfz4cA zH*)6t;p8Ol_W3k=i~=J;!iRD-OZX>KUe8KRcU`B~-WO=;zagKk7OQmjeB0eU8Nw{& zO!@5=mgA~D_^ynJ&KZ7qAi%07Y1-I!fM>x^dx57Mztb}@6T+{Rq3my{lNLwXVy02` zl*z1^MQwE3P&eQ~px}1h5Us5rU-Hp)xMXIcK%nF8i`Mj(a|XF!z_a=4d>6wN5z&5yx|}bl{b!Me8nXDJ>kS~r8T47L~gi&mg2PEkFL1;Wq3~g zv9GC;-pR96|Jx@>-6x&Od%h*JP4QDw2kr|=p-3fPtDRpSl{hN~#GzVY!ip%B)mKz8 zC1NY!j1M&4Mp)jHzP_8jH_E0h8*+Y7i@0S>1`Z4SWbGjypvhc2J(8|8GEUo}M#@L? z`GV|Et}LkIxr&<5GK}>T4{LEs3QQzLjBJkbZN58YlN^&Jo=?n<@cIDMl>Em&u4MJi zjB@eKZ$fP~T)c@e@d_9g0APU&0Q~RF`MKlS*R1bF`ZjynDj zow{bf(S^V@li>Y1Mli>)21gR6wcyG|^GfsW$;t4v`z8jDbp?sZ`rK>kGU^07{(2is zgm|TgnVj?+rzd{=h;WKp0&zEMLv((0CsDWaTKsoN^o3&iamWYvHYvNdV5^4T%yE%s z@Qmk-bOvnmc6{dxdeNNUp0!3nqrD9}BCLwHu&v83OCTRLG%JZh1pT3OTPLYqj!*r+ zM9+D-D&eRC$Lfdf5L`vSb+nAPCD!!U1A3?YI(dIq9!DnmpANp|hQHxFJ(toHbq@bJ zK0>(qP1aS-NN%pZ2iDj<(0Kd| z4^pvO`J+>JaJN%6l4!7A=b}v~mEnQgQz<}@Ls*16uf^|ERz~9E76%%78vjU0^da1` zye9JQx-fj$-?})#&UrnmdxVdl%7+YHGp)iPpk7#iysFZ)@dN+iAWF0Ph2i?!b$Bc? z>3eV|(;Cr)U3MeQ>si+#T-VNOS+2m}b(Pu+9Yv8;0No@MT z#~wwxbob=_wTqg9>F(4wqtK|T!Hn{Q{V#RHDDP9zboU}AxZ@UuGSgxIn6V-X{mjQ&47(g_`~HeIUvXb34RfoUo}|E{DPd+x0G;$IZ&RC z`~uz)^Md_m=4=3fQ$Y0*MXn^U-B(4vyKbBCEcw#Tc!0LTpPXGj-+RtWJCeuRTwY#Y zU!Hr|irE^ZE-HW@B_R&khAAa_-Eop~8O_P7$NQ^Ao`!A7$jZcuRa2dYh1H;}ZX8-n z9wM!8hQCfQBnY8j&I)T7m<+6I)!>2+1mGn2%clWJ^?uqiI(d|Kn1<0589wZlLph)M z5L_y-r&ZND3Izx08KUt7RX-zHR@32`gA_wsqTuIj+0{;aI|7y5^9c2`lXQ(t^V6&IG6yZSCiRXuj3 zva}jpFiP2B=Usj9P~rS)gnHf~9gZioO2JY($-i;*RT^5NWQ_cX=oAl{@hwPmu+6Ok zJtbQrI(p!>*L2pwwP#%@c@aUnWr?Gq6+K+bwRg?K9^uv>We(}qHh3P zZL1RMjeKfduD$rMvsQTL+NrX8{5j*CeoFkjC(=vwtPhur_e))5{IzypAiR(Op1<0+ z>2M^^oUOgBQ)!0XLM@xzHVD}w<24&r`ql2?z@X9|QEO=6DPm^sUHra%A%XX`K!)G5 zj8}S7IDZhI&GSTPFCBMtG>$J+uc?-R{$6@EKX<9K`qi_lKRCl$hA8H}jar^3=7V}2 z?!ZnG9u^;ogPFJ38mc5@p23MH!*Lkk7bkn;(mg=TTg)Jv$*+k))?dk_2OY@VwuB*3 z!>Uf+3Pog@=VCp@^EUzSts7wtLwDbK1uZ1W8yBKbLYrK0nE#c&)Fr*A$lUKorAFOQ zUPS)&btbIW)l*Vh6PX+KZrWR>dABhsHR`oiw(2^=A{!77teD824`0i;y@Y&D2|I$! zmZD!qcQbTrl%|c6Nh?$S?ok^pM0S zde!t+PHKZ4#|(}21dd5C6oF~TF%;Zj)-U3pd8@#m`xHs2!c$_BlUALT>uOC)xDRU8 zXa^%@M6!e`U+EE6oeq*`m~04gh1!Eafu25HBi<5cR9*`(uA82vvuGDkLA1w4ge<<^YaEK z*X(0T^fq>Oa0RkjUF{#4@)b`i@~TR?Wn~C;a+ErrE9cKq>6lJx95Gl;N-b1|FHK=J zwncEDlpM{l)hj%=F{mqhpPLCPm_>!&WB;ok6)cLZ7&ricD9Qh=ABZy|5jd{5*(d7z zdgyPd@#&;@1Nc+kII%n=Vpv!zxnDRyIv2`3>|cPnJtKUrF?9~*`;qS}yl0xkizU1( zyvw29<%2Bkk)N8JOrT&>#c+`L0f68=)1TA%CJ1}ubcwi<-~G40dbM%2IH?4vd*o$a zHSpNB*;06EbT6J4cu^q>PwL^xYZ%$9B>=T+$25$N{v_x*jmXRnmg^U>$WF@+RvUay zvFW=daa~{T`6iB*B3P^c%HXaqiu$^Q@a;JZwn#NqI+_U^O#o7B6{)4tIVY!RYe#8g z@(z$U#F zy|t|JABlSV_XVeiezdu^BMprjw!4gsupHlIw=j-JnqL!#a>q(Tk<%Rhi&1PJ%wzXi z7tU-iyW$?}cU5g)dHx~cy06;SB6y*D;Xnb`IXA+9K1!q!fXgQjC$@)?36>hFC*$!r zgL1lix)oVnu6-5ZL~ee+7Zq-Z$6@d2;h4@DVI4-vru`}O6pz+`>v_4WW|;jii{JSu z1=Wt@Aq|&IMgDJ9i3gxm)76gSiD^yVfmCzD)=!dA-nIR zz0@j&5ZaTB>gs{5`zmXOU$fz8wj)y z^3*)Y`ZKu5rBW)YjM{((T9WArlzPtCH5U&NP96lZxD8H(*gkF}E*XM0^I4Hcv6d;0 zkevsz`BLS|;D3 zKMJZRiI!J7>>wtqvL9@sKR?aPkl9}wbmFnf+sbcGZCQ6V-Llw9af_Nfct{nQG*!jL zH`$W1dS%&3dX_u`@{$afNvZ`NPf_|+QoD-q9wCL`DL(F^^vIM8uxAuIs{6NWNb+g? z!K|C*Ok7miMr|u@O{-uV=XGZUd`1f`sK`RvyR!CJfG2PbQ_E}p`^nR*n+|lQBnx)i z^r4pj+sXE--UhWcBJmpe*Z!EEjeQAh=BP=;xQHKwAOEa;{8n%3L*Pf@5i3rW41vI* zz$TaFrs9W28GbWyuBvMDNE5-x(P!>55Y;5$8Z?|ED_ zKd-H0@`j~JPKUIlL6^+XH2y+7gl`6$onP4|>$3yaCrJ3woQzMPbwkpSHFGtgFU%Kq za_;WpBGu{Cy)ax$@M8Yly{rBUakvR5FEkL=6))zfV=0b5t6#>hrrRYL?~@n`*Msx7 z+sGBSI4ODM^)|l2j*J$$U^rr18??2SPIY^F_gD#=(%~D=z%80NbXSq!(U!qF3m;g~ zLDgI6bbOUd<5i7dWBC^Jc-tU7zI2PKmXj*NXEFkjMNcNEg{E}*yn+LHXxYUIAnLCa*n<$MOU9`-Cvwuda@@dcm^i$a-S?Z{a^3M`D(J z@JAQfg?We1Cc$FV*f@CYv9%Kb56i(TYkZWk?mk`x%+kGyd;#B3tSr}+p zpSw|gr7~#9 zBvXFs**(Hmu%TveohQfNLc8_7f_;EzOP2M}{FRaywAG)Pve}YI5RT!-Z<8aK(!s69 z);6(i%k_Iy3a{c3QWGz#kgQ2hRuJr3#8FzRo6K7nol8UO`TfrmO{LWz0=Lz8tO;{v z!)C5_5~aQ(P;948t+gpaJ4g{q&Bn+mLDn8!j%CC&k$LZ7)GBJ$3S4ZUL6Gkd>^4s< zygNCa3e`-V6r8r@hU@>{+eJ@=#$8Ny1~&m)4P4Q|`pkGTTSZ3vJIN5HHC+>m2$Scb zF@3-DE%}}AdE4zsM;grx1AM0ilR~hqj7^$O_KvMZMKPzogZd9A8Dzqj1OS8I=)#Vk zJhx(BvcTflHb#8i#z^;&R7g_8)!y^%M1pKqKfK-XBm04}fG5bdBGcR;N`%@GQQ2`q z{K?-9zLMo@#sPwk{A^U*KhWH(e2x)MPLRNkF>OR+;ok ziiac;R^?hN;pG$K#v~XoL^-VloH<@WC9CAHjv8^)8dD!l8f$hp6fYo4vLrfVQ%Pp~ zSmfJNL`P(Q1nPm%@JbX_ zor%ngDCq|Jq}fVpENii?F+YS z1nc{n3iuwsA>sQ)`XLG6FB=TpS3o!PY6j@E$l$rwE4qOWf?@tU++?W?E6Js#sm_sW zx4EvY)}G{h__L55jQm(!SBy%=%>b|h!41W6z`XB6H&IU{{~3#EIFYP#U^h6-v(8&z zG%ZbkJQb=suZjd$uraAb(s`lVRW;5sqEefc~G^7F#?GqbPtO1Zm$Y=aI{rD#Ao`%5 z_18~e+wQH9ufj z-Ew zF0j^N3B&@IJeW>-jTz`Bh$8IzgdU+K`PB?&!{`hXM!21PH(XlC6e3apNjim0EuQV? zY_dk97aQ-KMtk^IriYRR!r~q<{&m|(p{ph_LI9wL`d_z=fe8lu4@Ljqe9d1X=RblE z_)F&i5GX3hKVE)`O6DI>Q}g`;RcfJs0H+rD2kq1n_!FU#TK^#+5qH$8{~7&<6+&py zP+;x>5g6F)h(sD9(7$E>zuiY5X%ra$P5p15SpMJn{|!Hg|L$c#&=ccOYO7)Y{UiVY Q1b?;cua}{JF8~1i7pK6RV*mgE diff --git a/BleConnect.java b/BleConnect.java deleted file mode 100644 index 909857c..0000000 --- a/BleConnect.java +++ /dev/null @@ -1,267 +0,0 @@ -package st.wow.git.ble; - -import java.lang.Runnable; -import java.lang.String; -import java.util.List; -import java.util.UUID; -import android.util.Log; -import java.lang.Class; -import java.lang.ClassLoader; -import java.lang.reflect.Constructor; -import android.app.Activity; -import android.app.Fragment; -import android.os.Handler; -import android.bluetooth.BluetoothAdapter; -import android.bluetooth.BluetoothDevice; -import android.bluetooth.BluetoothGatt; -import android.bluetooth.BluetoothGattCallback; -import android.bluetooth.BluetoothGattDescriptor; -import android.bluetooth.BluetoothGattService; -import android.bluetooth.BluetoothGattCharacteristic; -import android.bluetooth.BluetoothManager; -import android.bluetooth.BluetoothProfile; -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.content.IntentFilter; -import android.content.pm.PackageManager; -import android.Manifest; - -public class BleConnect extends Fragment { - BluetoothManager manager; - BluetoothAdapter adapter; - Handler handler; - boolean wantScan = false; - - final int PERMISSION_REQUEST = 1; - - final int REQUEST_ENABLE_BT = 1; - - public BleConnect() { - Log.d("gio", "BleConnect()"); - } - - @Override public void onAttach(Context ctx) { - super.onAttach(ctx); - Log.d("gio", "BleConnect: onAttach()"); - ctx.registerReceiver(receiver, new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)); - manager = (BluetoothManager) ctx.getSystemService(ctx.BLUETOOTH_SERVICE); - adapter = manager.getAdapter(); - handler = new Handler(ctx.getMainLooper()); - if (!enabled()) { - Log.d("gio", "BleConnect: enabling adapter"); - Intent enableBtIntent = new Intent(adapter.ACTION_REQUEST_ENABLE); - handler.post(new Runnable() { - public void run() { - startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT); - } - }); - } else { - Log.d("gio", "BleConnect: adapter is enabled"); - } - if (ctx.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) { - requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_REQUEST); - } - installComplete(this); - } - - public boolean enabled() { - return (adapter != null && adapter.isEnabled()); - } - - private final BroadcastReceiver receiver = new BroadcastReceiver() { - @Override - public void onReceive(Context context, Intent intent) { - Log.d("gio", "Received broadcast"); - if (intent.getAction().equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { - updateState(intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)); - } - } - }; - - @Override - public void onDestroy() { - Log.d("gio","onDestroy()"); - stopScan(); - getContext().unregisterReceiver(receiver); - super.onDestroy(); - } - - private final BluetoothAdapter.LeScanCallback scanCallback = new BluetoothAdapter.LeScanCallback() { - public void onLeScan(final BluetoothDevice dev, int rssi, byte[] scanRecord) { - Log.d("gio","onLeScan(): " + dev.getName()); - onScan(dev.getName(), dev.getAddress(), rssi, dev); - } - }; - - public void scan() { - if (!enabled() || getContext().checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) { - Log.d("gio","BleConnect: scan() not enabled or no permissions, wantScan = true"); - wantScan = true; - return; - } - Log.d("gio","BleConnect: scan() starting scan"); - wantScan = false; - handler.post(new Runnable() { - public void run() { - adapter.startLeScan(scanCallback); - } - }); - } - - public void stopScan() { - if (!enabled()) { - return; - } - Log.d("gio", "Stop scan"); - handler.post(new Runnable() { - public void run() { - adapter.stopLeScan(scanCallback); - } - }); - } - - private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() { -@Override - public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) { - switch (newState) { - case BluetoothProfile.STATE_CONNECTED: { - BluetoothDevice device = gatt.getDevice(); - Log.d("gio", "Connected"); - String addr = device.getAddress(); - Log.d("gio", "Address = " + addr); - onConnect(gatt, device.getAddress()); - break; - } - case BluetoothProfile.STATE_DISCONNECTED: { - Log.d("gio", "Disconnected"); - break; - } - default: { - Log.d("gio", "onConnectionStateChange: unknown state"); - break; - } - } - } - public void onServicesDiscovered(BluetoothGatt gatt, int status) { - for (BluetoothGattService serv : gatt.getServices()) { - onDiscoverService(gatt.getDevice().getAddress(), serv.getUuid().toString(), serv); - } - } - public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic chr) { - byte[] v = chr.getValue(); - characteristicChanged(gatt.getDevice().getAddress(), chr.getUuid().toString(), chr, v, v.length); - } - }; - - public void connect(BluetoothDevice dev) { - if (dev == null) { - return; - } - Log.d("gio","BleConnect: connect"); - - handler.post(new Runnable() { - public void run() { - dev.connectGatt(getContext(), false, gattCallback, BluetoothDevice.TRANSPORT_LE); - } - }); - } - - public void disconnect(BluetoothGatt gatt) { - if (gatt == null) { - return; - } - Log.d("gio","BleConnect: disconnect"); - handler.post(new Runnable() { - public void run() { - gatt.disconnect(); - } - }); - } - - public void discoverServices(BluetoothGatt gatt) { - if (gatt == null) { - return; - } - handler.post(new Runnable() { - public void run() { - gatt.discoverServices(); - } - }); - } - - public void discoverCharacteristics(BluetoothGatt gatt, BluetoothGattService serv) { - Log.d("gio","BleConnect: discoverCharacteristics()"); - if (gatt == null) { - Log.d("gio","BleConnect: gatt == null"); - return; - } - List chrs = serv.getCharacteristics(); - if (chrs.isEmpty()) { - Log.d("gio", "BleConnect: no characteristics found!"); - } - for (BluetoothGattCharacteristic chr : chrs) { - Log.d("gio","BleConnect: -- " + chr.getUuid().toString()); - onDiscoverCharacteristic(gatt.getDevice().getAddress(), serv.getUuid().toString(), serv, chr.getUuid().toString(), chr); - } - } - - public void setCharacteristicNotification(BluetoothGatt gatt, BluetoothGattCharacteristic chr) { - gatt.setCharacteristicNotification(chr, true); - - BluetoothGattDescriptor descriptor = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")); // Client Characteristic Config - descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE); - gatt.writeDescriptor(descriptor); - } - - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { - Log.d("gio", "BleConnect: onActivityResult()"); - if (requestCode == REQUEST_ENABLE_BT) { - Log.d("gio", "BleConnect: onActivityResult() REQUEST_ENABLE_BT"); - switch (resultCode) { - case Activity.RESULT_OK: { - Log.d("gio", "BleConnect: onActivityResult() -- OK"); - if (wantScan) { - scan(); - } - break; - } - case Activity.RESULT_CANCELED: { - Log.d("gio", "BleConnect: onActivityResult() -- Cancelled"); - break; - } - } - } - } - - @Override - public void onRequestPermissionsResult (int requestCode, String[] permissions, int[] grantResults) { - Log.d("gio", "BleConnect: onRequestPermissionsResult"); - if (requestCode == PERMISSION_REQUEST) { - boolean granted = true; - for (int x : grantResults) { - if (x == PackageManager.PERMISSION_DENIED) { - granted = false; - break; - } - } - if (!granted) { - Log.d("gio", "BleConnect: permissions not granted"); - return; - } - Log.d("gio", "BleConnect: permissions granted"); - if (wantScan) { - scan(); - } - } - } - - static private native void installComplete(BleConnect p); - static private native void updateState(int s); - static private native void onScan(String name, String id, int rssi, BluetoothDevice dev); - static private native void onConnect(BluetoothGatt gatt, String id); - static private native void onDiscoverService(String id, String uuid, BluetoothGattService serv); - static private native void onDiscoverCharacteristic(String id, String suuid, BluetoothGattService serv, String cuuid, BluetoothGattCharacteristic chr); - static private native void characteristicChanged(String id, String cuuid, BluetoothGattCharacteristic chr, byte[] value, int length); -} - diff --git a/BlessedConnect.java b/BlessedConnect.java index 0db8486..eb49268 100644 --- a/BlessedConnect.java +++ b/BlessedConnect.java @@ -18,8 +18,6 @@ import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; import android.Manifest; -import android.os.Handler; -import android.os.HandlerThread; import android.util.Log; import com.welie.blessed.BluetoothCentral; @@ -45,11 +43,7 @@ public class BlessedConnect extends Fragment { if (ctx.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) { requestPermissions(new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, PERMISSION_REQUEST); } - Log.d("gio", "BlessedConnect: creating HandlerThread"); - HandlerThread thread = new HandlerThread("Bluetooth Thread"); -thread.start(); - Handler handler = new Handler(thread.getLooper()); - central = new BluetoothCentral(ctx, centralCallback, handler); + central = new BluetoothCentral(ctx, centralCallback, null); installComplete(this); } @@ -67,9 +61,8 @@ thread.start(); Context ctx = getContext(); //The Blessed library does not expose this functionality, so //we need to get our own BluetoothAdapter and check its status. - //BluetoothAdapter adapter = ((BluetoothManager)ctx.getSystemService(ctx.BLUETOOTH_SERVICE)).getAdapter(); - //return (adapter != null && adapter.isEnabled()); - return true; + BluetoothAdapter adapter = ((BluetoothManager)ctx.getSystemService(ctx.BLUETOOTH_SERVICE)).getAdapter(); + return (adapter != null && adapter.isEnabled()); } @Override @@ -81,12 +74,14 @@ thread.start(); } public void scan() { - Log.d("gio", "BlessedConnect: Scan"); - central.scanForPeripherals(); + if (enabled()) { + central.scanForPeripherals(); + } else { + wantScan = true; + } } public void stopScan() { - Log.d("gio", "BlessedConnect: Stop scan"); central.stopScan(); } @@ -117,7 +112,6 @@ thread.start(); @Override public void onScanFailed(int errorCode) { Log.d("gio", "BlessedConnect: Scan failed"); - } }; @@ -135,20 +129,15 @@ thread.start(); public void onBondLost(BluetoothPeripheral peripheral) { Log.d("gio", "BlessedConnect: onBondLost()"); } - public void onCharacteristicUpdate(BluetoothPeripheral peripheral, byte[] value, BluetoothGattCharacteristic characteristic) { + public void onCharacteristicUpdate(BluetoothPeripheral peripheral, byte[] value, BluetoothGattCharacteristic characteristic, int status) { Log.d("gio", "BlessedConnect: onCharacteristicUpdate()"); characteristicChanged(peripheral.getAddress(), characteristic.getUuid().toString(), characteristic, value, value.length); } public void onCharacteristicWrite(BluetoothPeripheral peripheral, byte[] value, android.bluetooth.BluetoothGattCharacteristic characteristic, int status) { Log.d("gio", "onCharacteristicWrite(): " + characteristic.getUuid().toString()); } - public void onDescriptorRead(BluetoothPeripheral peripheral, byte[] value, android.bluetooth.BluetoothGattDescriptor descriptor) { + public void onDescriptorRead(BluetoothPeripheral peripheral, byte[] value, android.bluetooth.BluetoothGattDescriptor descriptor, int status) { Log.d("gio", "onDescriptorRead()"); - if (value == BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE) { - Log.d("gio", "onDescriptorRead(): " + descriptor.getUuid().toString() + ": notification enabled"); - } else { - Log.d("gio", "onDescriptorRead(): " + descriptor.getUuid().toString() + ": notification not enabled"); - } } public void onDescriptorWrite(BluetoothPeripheral peripheral, byte[] value, android.bluetooth.BluetoothGattDescriptor descriptor, int status) { Log.d("gio", "onDescriptorWrite(): " + descriptor.getUuid().toString()); @@ -156,16 +145,13 @@ thread.start(); public void onMtuChanged(BluetoothPeripheral peripheral, int mtu, int status) { Log.d("gio", "onMtuChanged()"); } - public void onReadRemoteRssi(BluetoothPeripheral peripheral, int rssi, int status) { + public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) { Log.d("gio", "onReadRemoteRssi"); } public void onNotificationStateUpdate(BluetoothPeripheral peripheral, BluetoothGattCharacteristic characteristic, int status) { if (status == BluetoothGatt.GATT_SUCCESS) { if(peripheral.isNotifying(characteristic)) { Log.i("gio", String.format("BlessedConnect: Notify set to 'on' for %s", characteristic.getUuid())); - BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")); - Log.d("gio", "Reading descriptor"); - peripheral.readDescriptor(descriptor); } else { Log.i("gio", String.format("BlessedConnect: Notify set to 'off' for %s", characteristic.getUuid())); } @@ -205,6 +191,9 @@ thread.start(); } public void discoverCharacteristics(BluetoothPeripheral peripheral, BluetoothGattService serv) { + if (peripheral == null || serv == null) { + return; + } List chrs = serv.getCharacteristics(); for (BluetoothGattCharacteristic chr : chrs) { onDiscoverCharacteristic(peripheral.getAddress(), serv.getUuid().toString(), serv, chr.getUuid().toString(), chr); @@ -212,9 +201,15 @@ thread.start(); } public void readCharacteristic(BluetoothPeripheral peripheral, BluetoothGattCharacteristic chr) { + if (peripheral == null || chr == null) { + return; + } peripheral.readCharacteristic(chr); } public boolean setCharacteristicNotification(BluetoothPeripheral peripheral, BluetoothGattCharacteristic chr) { + if (peripheral == null || chr == null) { + return false; + } return peripheral.setNotify(chr, true); } @@ -269,4 +264,3 @@ thread.start(); static private native void onDiscoverCharacteristic(String id, String suuid, BluetoothGattService serv, String cuuid, BluetoothGattCharacteristic chr); static private native void characteristicChanged(String id, String cuuid, BluetoothGattCharacteristic chr, byte[] value, int length); } - diff --git a/ble_android.go b/ble_android.go index 779a94f..fff5776 100644 --- a/ble_android.go +++ b/ble_android.go @@ -24,7 +24,7 @@ import "C" // Types required for ble.go type bleHandle struct { - BleConnect C.jobject + BlessedConnect C.jobject state int } @@ -131,7 +131,7 @@ func (b *BLE) readyToScan() bool { connect() var ret bool runInJVM(func(env *C.JNIEnv) { - ret = C.enabled(env, b.handle.BleConnect) == C.JNI_TRUE + ret = C.enabled(env, b.handle.BlessedConnect) == C.JNI_TRUE }) return ret } @@ -140,7 +140,7 @@ func (b *BLE) readyToScan() bool { func (b *BLE) scan() { connect() runInJVM(func(env *C.JNIEnv) { - C.scan(env, b.handle.BleConnect); + C.scan(env, b.handle.BlessedConnect); }) } @@ -148,14 +148,14 @@ func (b *BLE) scan() { func (b *BLE) stopScan() { connect() runInJVM(func(env *C.JNIEnv) { - C.stopScan(env, b.handle.BleConnect); + C.stopScan(env, b.handle.BlessedConnect); }) } //connectPeripheral attempts to connect to a Peripheral func (b *BLE) connectPeripheral(x Peripheral) { runInJVM(func(env *C.JNIEnv) { - C.connect(env, b.handle.BleConnect, x.peripheral) + C.connect(env, b.handle.BlessedConnect, x.peripheral) }) } @@ -163,7 +163,7 @@ func (b *BLE) connectPeripheral(x Peripheral) { func (b *BLE) cancelConnection(p Peripheral) { connect() runInJVM(func(env *C.JNIEnv) { - C.disconnect(env, b.handle.BleConnect, p.peripheral) + C.disconnect(env, b.handle.BlessedConnect, p.peripheral) }) } @@ -177,12 +177,12 @@ func (b *BLE) knownPeripheral(p Peripheral) (Peripheral, bool) { //DiscoverServices asks a Peripheral for its Services func (p Peripheral) DiscoverServices() { //launch a goroutine because this function calls back directly - //from the same thread (underlying Java call is synchronous) + //from the same thread (the underlying Java call is synchronous) go func() { connect() log.Printf("discovering services") runInJVM(func(env *C.JNIEnv) { - C.discoverServices(env, gBLE.handle.BleConnect, p.peripheral) + C.discoverServices(env, gBLE.handle.BlessedConnect, p.peripheral) }) }() } @@ -191,23 +191,23 @@ func (p Peripheral) DiscoverServices() { //to a Service func (p Peripheral) DiscoverCharacteristics(serv Service) { //launch a goroutine because this function calls back directly - //from the same thread (underlying Java call is synchronous) + //from the same thread (the underlying Java call is synchronous) go func() { connect() log.Printf("discovering characteristics") runInJVM(func(env *C.JNIEnv) { - C.discoverCharacteristics(env, gBLE.handle.BleConnect, p.peripheral, serv.service) + C.discoverCharacteristics(env, gBLE.handle.BlessedConnect, p.peripheral, serv.service) }) - log.Printf("discovering characteristics done") }() } //SetNotifyValue subscribes to a characteristic func (p Peripheral) SetNotifyValue(c Characteristic) { runInJVM(func(env *C.JNIEnv) { - C.readCharacteristic(env, gBLE.handle.BleConnect, p.peripheral, c.characteristic) - //result := (C.setCharacteristicNotification(env, gBLE.handle.BleConnect, p.peripheral, c.characteristic) == C.JNI_TRUE) - //log.Printf("setCharacteristicNotification: %s = %t", c.UUID, result) + result := (C.setCharacteristicNotification(env, gBLE.handle.BlessedConnect, p.peripheral, c.characteristic) == C.JNI_TRUE) + if (!result) { + log.Printf("setCharacteristicNotification: %s failed", c.UUID) + } }) } @@ -236,10 +236,10 @@ func Java_st_wow_git_ble_BlessedConnect_installComplete(env *C.JNIEnv, class C.j if (b == 0) { log.Printf("BlessedConnect object is nil!") } - gBLE.handle.BleConnect = (C.NewGlobalRef)(env,b) + gBLE.handle.BlessedConnect = (C.NewGlobalRef)(env,b) h := app.PlatformHandle() setJVM(h.JVM) - if C.enabled(env, gBLE.handle.BleConnect) == C.JNI_TRUE { + if C.enabled(env, gBLE.handle.BlessedConnect) == C.JNI_TRUE { gBLE.handle.state = STATE_ON gBLE.ready = true gBLE.events <- UpdateStateEvent{State: gBLE.stringState()} @@ -384,8 +384,6 @@ func goOnDiscoverCharacteristic(cid, csuuid *C.char, serv C.jobject, ccuuid *C.c func goOnCharacteristicChanged(cid, ccuuid *C.char, char C.jobject, cvalue *C.char, length C.jint) { id := C.GoString(cid) cuuid := C.GoString(ccuuid) - log.Printf("goOnCharacteristicChanged: %s", cuuid) - log.Printf("goOnCharacteristicChanged: length = %d", length) var peripheral Peripheral found := false diff --git a/blessed-full.jar b/blessed-full.jar index cb9affac749bc6e3d52e24c25e7ca672947ea968..e6cd12a53c597a9cb4679160fd8c1d5e9c6c56dc 100644 GIT binary patch delta 15330 zcmY+rQ*fZc8m%4Mwr$(CZQITSUox@niEVq5Ol&6;JDJ$_zxS@c&Z*NEebMz+^}2Yv zs^9Ll9{xeRA3-z-RRQ|y8(Jt|NNp%El&&_(V6;Py3g-CG<^_n5a{A^ngt4-$86b*L ziD8Un6w>LW0uKWv8Mc6!)!Q63kzdw6Tdpl20;rcS3Jwgd_LvA9H2ZmYJzoU+C4Ie| zuk3&#?Ag-uu?}RkzpzbYu)?B^Q2vf;r&QP_guUMH!5WfO0OWjNVPVxX|BZUT-oDq$ z?B_*dV9UD)^P)cUeilI98<6!|vis|zG}4$w?d`{#K{V;9wm$weUqc9>9iCcG&x>=y zp`31HpeByXck#v?mHmxEWS-d3WkrV{KJrJ4{)x*|oi!a}!OTW4hMj}ow+9Euq$5qO z_VT38>I83X1&Eep)Nc(mChzv0)wav~Jw52(OaU6{E#g0T&RUzuOSin2X;NH+{ zwBSL|hKsJvnz1ly#9StgD=Mx=m~Y;%)Fe62VAP*=1x_*?x8|{)-~^~;!{KqIRf%Wm z!sJNQM(Eb6xN7eeNBej-`bsZoLMKxz@w8OA-J7#h+MCGIEd~BW$78R>d-K;O2~tkBMV9QVxnJ3~`Ci!g^`3;xV5}aW!yo z=F85Mu23JNspAfmSTPTVQWghMBec&#b|c^)TG(WW8`U-}ifVSpKvN8g%8np;;r@(E zN7A&w40}!1we8prf56qF1!X$)LlEzG|GR7#39NT1s%mzTpy1;cF!iq3$cN8##Z+-E zxooI~9iP!hkzxtlrvn}naqJj4UEl3ixDt03jV0E!>>hnNzmkjb=ZA+aezq4C-@Br5 z));v7TUKJyn)jPjWsk+0t2@WlmY&i3$IeDzCn6&wsA+P+@hWl&x$2L7Pe5S(e28^h z1#XQ6Mdvj-70j#zvy2LQtFg<2RkV)~KCQJDD=Q~+6Jguc52B<<5otPg?&t6o{(`tf ztQd6cW%HNv@vyPD5iL`EJglevnS-pK9hD{!NiF*&Z#&nS`j5D$CFcY{2Ti`BWK#4C zw$bjmMqwb}l~C_^N6B+3e@5B9VMYn`06dM#TeCb!a5^MEI9HUgf5Lz>jn=An79b~? zZ!jpP_jo*szgRbrbD-POiBs&;79a8QZRq#(iR#^IAWhgz5{Uj=cz7n-8(YdfA?@>;FjTs6$37mAK3b2 z)Wn^b!f&BenFCO^M8}4=#l7MIJfSHQtdAT!sD$}9ZWVcG7%$H%_%H|%kV@E;`4;IE zta>^C6D%~yK?DUOCImxAN0hOE=frlEFnQQAV_o3^@Oe0#u1*hB7m{rEWnQsos#2e=< zrdF}Uf6#hBid(P252d_qw?%UC4znCi6b^ne68Xw0$J$E9^cx_8p)$VyDv)L5%3v1e z6z5P^6)fm3NH$(i-1O}nc}Dj!C$Eu?*SSqyc*l+$H~fl5-#GenJD82F@i(+4ye=M) zMdy;E;+wN2ixEOs&*ZWNVMhoNa4DX1kJ1P8i8sW!QsE+OMi5Nez3N(pFV(4E7O;<4 zjG0W-ly%I9#(Y10s&grc@22|4;=E7Pg)>4x1X0*RC#HuAsigB>9?JN*8@j|KO;;n< zoLdC?tJJU_TC`YvP;r>u!=Q%J>BSug_qyW2NXyS=o_7*-`k^}UZL>$tL^-`IQ&5iS zc2D0i!E!_F63%p5Io3 zdQRjUwiA&hO-g-0ykeJ-6}U=To{+?&ZeePjS(6vlcM^G}^at&JOMBOS7Rlbq3=6y! zq9-Vy%p5SkhA57azC#;n7px7M=?Hz)D#dB-W?F*fIhx(L=CLphDK1tO?0Mhkyl zb)bDf{g*={{BB7A3z75JU=LO%bJfV1PkT`*!JI5m~SeI0P^C;V^g zS=$-p*I*h2pR1G;FQP1hJd{Hzj;sFo+Bl;zahC)@QnTmI3?#2^1 zl$Mpv{kax7_c)6l>z3m|VFROS%|_8Y3a9xzQs{M8;Ai?xO>Wmshap)8Idq+fzo{Sx0PFgKb_k zg~yy+7XIQauvMA5TQ7EW_EIVs4@(kKGMsckRK0YJ6OKMMC)u}k{je73b{FBJ-%-er zvwA~g+Ocb`fQ?9UhK^sXS#Xj6(wH99sBnLE+hY=k=2mnYSDaQ{@L+7`qXWVwj3>Nv z--S4}VhYMB-5M<|vYAa!kj`S>!^?wk=jng!uPwZr?gLAcr%B1MT)qoZf9w8I)g z3!!)5<8NXqaW2Fl>d=BMuK`Fdhwa0;c}tgTs*#_JUXkCg84XtlNEpmtg6lB&Xy3gdfMVOMiLu3CARB%E%mL}hXCZDz5zrW}X)AC4vOx0N` zfhVshO~gS+5~h6c7gPn08h0cq0ktgo`wR>I2grX>Tq~I-sRRQ_nQ8HWmyGG@27~Sm zs`qb5QEcS`1`inSDk^Nbpb5S2SX7oxk@^=*k6qwf3I4Ivw?Goc$4iDc8WL$_iy9B9 zjpTM+c=@gtIeO<@yHW3&Zul-Di*F+gp+hlVz4XBKSJhE>&*Z`Q@6D;!Q|ry#qchh_ z9$tG$41q)Xo<#)yo@lT`itMCmX&p|ioJ=>N=?bI)xZbwPBDt1v2P5ePi5zanw9gNw zV~ZwCej|vZE`uxW+1MhF6gIUeEG?=Em#k^@tDEJUejv2A1}I+)^&*Tn%tdxSo913q zG}0a+bcSC@=lSf>GofRL>ZsJ6aM>4PkL3}!tw?SrF%rr{U70P2pi+WE8gQ}Hq_41y zv-}VR{KIjto!2JzE$Tmvq>j>89|cwGW}d1LN`W!$X~(@`D9@l&vg47e*y0$g?F3xk(QRWmPvZRI#G*oEo16w(rLk!Se1sFB$$la@Cj*| z4T5>7lC*5~BA;TD%?eWgMW=YlMZF9$MYuVKy#-9|PuGQdie0jCSd#fv`L3F(ug1ZI zP!+B8Puxo9F&6)U7JdAAHsOLk#YLv~pM@i+O>%-_S0a!i=^aL7RCI?Fok3P))zkfg za|{?9`0RR!Wn6$1lVuwLR6NscqfIrb|mu!>U;4;uMnMu>ENR|2IXVg9#XPwMN2gn%Gn% ziT7*nm`#!oGGz>g9;4S#DXUP3GS4lZYH%^r=``P)I0$w@j3M3O$SwR*)loY!l=sOy zIi0OZx*;4T{w<`uX&LzretJ{|ktd`7ri}XpPZ}d$hKY=8hFDIGldNbP^Ven-(`mE- zFWh6174dw|r8Js4h85sM4{5XB7;w~qQdQT1TVdATC^DDaN>Xeq$fjPO8RHy=uk6rf zrmZBvrG`>`-sEB&P4W6Jy@6Iz9)zMR@vmsZQ87&KssIc(~9R={(8Wh`!wICL}Cj42N zF4-M31b19MM_wHWc`=xx@Shga3Vt(xq_b)`gqgXomtJ;zFsT7aNDAIH`bx&v5Q)L6 zKMGw~-^K5ZL4Ok6hubb-bn5lUC9tzbwP~s#@t?o<^ktp#FTZ{NzKS`!#A4Q$NEce+ z35eH5ku6<<2LZ;)Q>8-#V`LVu&mvi;&@#s9@NTf`(2QWC zQx3I*L1^XB&{mSNP>@)P=~QHAhkD7snDpLaPq1&EaGD{=&8KLw<)`D5R3hV8zrEI- z!_NAj8;6h+_Z$y>pz%Kx=ZyKy^BxlRrBpo8+s8(2t}(dkP}RQ0^;n1l!T*a5u2j{d zPIGVi`mDMA8Zl9LMsNdvJ-(6z{+o@e+^}8)w(_s>7NKbFvzQoYC)vXW` z2IWtx$gjDa;7k=X(FO~W)I@9QNFS;G>H6g24}DIfg!F7)peP2kPsmFa9TQR#2xq(V?(;}{&Z1#Jn${_ z1ikDxX!K>dPN-SPLzJ3Zq!9Fpd*U6E>IKU%Q^9Q5Luce2Q`suz!z%_QbLpz3Q^jG1 z`o-cy=T9N+g=4xnU<48V^$4$T9Z}LM*PbJ=7GLfKHO}}roDHttTbx(8=pLUVus8=u z-vLT)bG90$YQA~nh?ifEJ-;BiYxdha_N+g&a(BvZH?|t`^mYn^Uh8v4I@FK7Z9km2 zm+r_@d!>(`(H7o40;dpTcj|AUHyhH3vxbNdjZ2ab_yCz>aE?;I^1LB&OO5~4#YbI z(J#EXPlkZJ;@JR+wR;S|;In{SA!f8p?5z*{kDbjwuiVtP884H3-{~`bil^EhU)Olw z@%TtL-*d0P*+)0ucU}&V|D7@Oos<0~av-1x3;gXnvQtOgcM{ACdeXD?+lS-88?@#QUcS2OZGi#Yls?9rxSJ?Yt|c1(Qo zA)X7A-2X?LxnU4fCQ}DfC=+1NrQ%U|Cbk$>*Syv>HW#Lko#J77V%EgO=EJmLOz=uD#7MLsP!Bx>rnoBr0tkFJ(zQ{J@kyIar8>ui=GRyF` zOJf9gd}78FcJIMTtSQ1UHzcOWupp5{g=Jr)gHG8+BPkojX2>uv;R`^~{mI}|4UQ(6 znUg5RH^P+Py5S256eFfeSB;S2q6^5;3C`&=jiRVpgreN!TEWa?Plrvp78u958Y_l*_5SBI_477b(16&bq#ehlUF+-A_p_q=iVBb3MIm3epVLu|&z`%UZ%zS4i;osfKEU zaT4`^D5FOWseXu6#smtAn&ygxN5w@VPL5k%#)xWj^9I1m+IB~4qph^Lnv-IHrhRoi zl%LnXzbmHYGqLMWRX-qfww7e<7HK+nrIu51A8tAGBz;qG6q@c8RPihRjS-~E*4C%7 z{9PuoZUopDC;Fcdn$Vgm)STSpb(xC`?X0c!W9pI02dDIm;s0%Xa&Yc*RM(%0V0m-N zlzA7o5R?MxhnIKN%4}l^mTitwzK%{+^_LE{b~cU~5=R7zx`k~{>Y9Fnwu#@Qp`wW@ z(*ZerC}!5v|EkjIC<=#HqS3)k?F>yhP$P;~HG71Y2w|bSCoQ#T^o-20_LjV_PvIR# z_IpJ_`!TxBd>S?i{tuJZbmOw#d*9xA0n~DRUlZH;>c)#Nzqvd|WW%8|q_QA&71p z!Quy^WJtgf8+^4z3zVPu*NF12s$O{iS`4aK=cl1g-VsR?r^x4w z?3C`Y%t8|>>`W}wJNRB-(u zn}Tyk39veG4se&XR95l{g?2IFz)87k`gYkE93+LazG#buoZErDn#`{q+nC0Yto_ z@G&2VZ1Jhv?23rmB`T&uf=_hda5S(K6RnDrfo3aYa8-#@*{?#I4yyFyt7r(7z46^K zIGfxh855TZzd@bSKdgS_!FfU#C7TT5dbo-b(qUcVhQYx$ECgiW zcyTY{A>ey57~ZlR<)4LhBKcw9)w?_kU^*Re`%#2`;G{WYWqCxY2yUhY%qWOUe0nsJ zK)1g{zTG-UY$73nm}#dU_DGd*8w?;j(Vzti?aQOSpex@QFgnx z=e2Rc!pp%zv=tDjjgeR$Q-~XO@0P$%JJ;%gZk zzMoB;GyLSEk$J8RK4>)}f>&WwWcWM`Bk$$S?Rql*m6P;&GAxG_I!z(3bbaO+aME3E z`+?9B758__h);FK=IjSLHx;`?#XvF#EHpfpQsm(8No#8WY)9r^iiVXsy@?fSGR*1a1(+8(GHwwlQKAwX?ih}x z>Ou=`e*g6PGZjT^U|B;_4`Z1Q2fYyjoOsjuF;IKBAYTe3+iM|1zIVC${*}PutuG6s zZgfI=K%7J4bCH8=_=q;N?G7yGG(TK}LU%($md$>;5D(R{uY%;7+u~dL&!YhQDtqXa zfSof*8-^SvNiD0YU6C3(W|T%z0rbcGqH30iDBp!l#6%}jk$*ryun}OKRx;R`no)WK z>R$+c!l)X?1wc$UHTR~ptv+NOoD{RhPBl?!{m!Lo8wYP6&en;fvwWNvqS<1DJpNi&CwcKRLHNdt`q_H@OUggIU>+%_g(Y8mL^ovXKJPfHK6^rz zsQmY#-Z)ql#(19#Qe&!skZm)Z6*Fw*rcSZRJS&F#>$F7YUoD|M(2tcr@s4R25c0Ga zT#Ubz5U4x)K)oCogYO&l4$n4X?mgBN<2ihYsFffp^NJ3U6*Fn0=?`v_d&I<3TPiv% zy~DTB=)H=8@Zd?UcfD%U1OuJ(Q(le&@A=jiJVA{?$sM1(o%!ko6*+6A#4u!;To$8v zuh3@0NUvltbgE#HA(iL>ESyYZ^fDvdAy86sSc1f%U-L{w^7kt)X1s)@Bqg8t>C;hh z9Hg*^RLbrX0ifR%P|CNf`-^Uo7v!g5z7V<6+FCTMSNfd*JJUXFWeoGS+tHBTRdl<7 zB%}PIqpg$QYvF_sbaf>-@J8^GfowuOY%Li^?kOc!#YRf$8F)+`%ZN$A3%Zc^E9O*S z$*Efav`M2v6Mac(bi8tFej?NnYUnn)4AspdS)X7} zo}e-V@#anQr{rwqms?8G)bI*ifBNT9q8R!jSDDY4k7G=jjcXiCHPFJ?0!k@4syJko=RXL%FSxr#6JY?%_??bbIxr#xtWA`K4 zHGR&17+@T?)z=&=n99bhdni;>Sn5(Os&^xa3?F1)^)IH0)2B(}m7;p!n)tCtKHqJFsi9 z-?Yp#q(eOCA*YHS(&N}&M2s@M9w%DtnIwy2kxXd_9<%+JoTK%&1%sKs=S=?KU)_eg zuwSJeTb@){Q#q>K!_-VBW;qVEY7@grd;13EeZK|J0x>IbD z1D^FPx;X)CBEzXUIdauLQCp*E_e!2o#&2Enhlp*S*gc(9w>4dQhc&BCk%VT{A$ND- z5EFJ2K3zQ$!}!<^_ztRhZRfcRb=&ms0%RdulUD7TaBS_kBk z&Y)k0-^2(aG$lWIW}mQ0aL=+zh&n+;lZZs1=tgzC<5&`PX? z>drSqZh%Jg`XyKb+hUdw8A%ESsWeO~PJohI;oC!TxLe?js<r{5SYcN=JoT1XB3Fr?BSjwZit+v%78fZ1E`8kG^65f(lN`{Db*y;G| z49<4y_k4q<%Q{syk3%H|86+XYlt|whvsqXY*g*|BcETIsA{%X-%lJ@ z)DTK@T+^R;3Fwr!-QgS(`Ah_Q5ktc^`6Ed&<|_EIr?!a{* z6UW0~FGZAj5qJXJUFZajniPL)ljcKZg^p(9Z|ldr(#aoBHv8(~9U2B!k(0yauC&ny zXOhLb>gop)5^Y?tlVB~nis2n#0T`~7hCH=|>ZG<#S?w)G`}EmkOnN=$?9(XPs@SJ& z?zF7;>X1^NcoTHI(xBK!5P zIp29ec^bB#$7$(vuF;PjTfs{OrVM5No`;sjAK|uI1;M|c*ry~25T|ch33;YQla0=g zN;8a%^b(kQ?&eD$w}A!uYevg>9pIulneYz2}Zw*)y5&}M$x1>iFKeYC8g7J$LEefyNd@nd^OK6 ziJ~d)22tdPuw8^NI)Vl#4jiiH`(^JLLJSu46N}3$og($eAN9$c*k3q=wouwrxcwqJ z7E!#Tx;f{~A_2dlp70K3g279jyV9h7cHeX=Jw(?&ACRpL3~xSv- zP;!0j$lc~D={PImuaqgs*hZ7yPhj*;2uR?0(y&v&Ja!Too=?$LpjHOo6Sc6;|8@!5 zcEK*~id_|>&aDG|t@75Jz|$b5KP6-Z-@Cq2BI6tZtC{VZ=2rfjX6ZE0V|&rWI%=z2 z1j?&u0JNy=>zNq)v#t8z&E#z5-Z81BbSIP%{kTbT0W9L=>jxBPqx;V=C`!>hs$xvc z6FTSPK5vFPBl71S@$F*7=*30CPhJZ)STXRbh2a1Be|WFUW_CuQsjSrdA%L@UbWd0tD@X^BjayPLIW0ujHuTdv!N|Ons+0 zrCfS3bk(4&%Yh?S(UPY3C*^3w8Elu;>v&}(FSXgMD7A8F+y6*(fX&RGxG7b^Sb{1~ zG8T5-Qt)ZbFkaD->=RDzBWetkT<+|t>Lo-R=ct}q(aF(J3o`obm|p08%mJA*?5;in z=&yoZjENzGL6}PLzxwK`PEi{H6B3b);ilWH{QZ8skO2+moBiP*OM!yr`{6bDdA_wu z?uZJWqQU_J)P$FE0)O?o(*oBeuep<}4zkfK=J>zfKOczaUl%$pC+XLZN(TA*OSp@` zWmGkKW1RWSLkbMiO7+Uhr+zQdw5}7U-E!IgpBAurd}*oW&FA5*Nlp_FT)Mg{inx+4z>=)A4u@ zsW4;A-7QyADnZXAR=^uP$_k^cl3bQUH@T_UepsaxGN0rR}3a;!& zrNaKKn)DCcvJCzOdX}DrB%`p#<;*f-xcbI{R;>=Da7c%M0Ut<*5b^-3GH$*F&CEKl z5?Nw9!c#s4XSqb=a(F%5=SD`h&51M1)jxQat3%nA9dWHD-CDTLgMD6Yh9llOdrI^d z4FiS_?Fh5!9xh#I>3cwDje7VoYv0xm(aqdvRjhY&5Q1M#L&jyADas>W!?uuDFT%S{ zAA&d=gUKF5CuT$Nf2U7b|5%E#+8{)}1yu!P$`fBu{=|Y~N1CFL3zUBZBdf>#kfB!+ zw=`3iX(;2Y<5x{)*#C%IYi*^&33vhJGyU z*@Q1y2tA801F#guWpl=yjL-{&yj`Q91#ZHOXjvG%Nk}V(>KM1JHlj!JxP3@pBO!65v!3ni9=hM$f_ou5o`D}x~M_f z)E}!uD7>e@?m{iju&i;C^T{^Ou&|LH^r6!UV@C6W9Vm-*5ny`Ph%)a?kY`1kcACIk z6hU32tP^NXkCRU$Cuj2F>>fEg2UVe1xExj{Dfx40(`qSD(aNKhcW0ePNnLoZ*#-1T*&J{6X)Kbe z09cMb>a^?F;|p5zJ_x)_q!}Za0d$s`;1ueHNtR8BUgH*M-3+J_DC=lSSVerpIfDat zp+VF!y`oAAOC~RvKGCqtFndGVpJic4M1sH59RT8HrX7V7r|xF2_MW&#?$mH_;_#%Bly7F0mNtqAF*613rUKJ!xEtk7Ayc`8dTNVeAFU=TgLOAsU6&yqiLG2Rf+|9Z;aMIKbnne{w_`iU)LYA7LSjFHHuA}ws^Lw z5mAEf5M9$(u66>DCzSHwMC`)kbLi}R7-{nHB^x2=)anaHnG!!Ji$HG8haS;chN=_k zjl^Gn2df_|F7>p}?SEkWjcPBH`v4GXXJ$y^2(6ZE&ZrB-PK^XR=IANCQZ8=_CuOE(YlV^RxWYsd!8?O0%X^|jQl>F>@mmK zH=xg5RhMlgS0ixW!yS8lY$jrWqM1O1aQJ5&racy7U#(d_i>CLIZpUooCxG&qZXL?XhD{cffr34kL4nUSbVys{|Ydi%0#pDJ3YQprD1EQbRg=@~%5mq-w6U_MU z?Ze$Pv->yLC(UZt)?xB&`ZbyUKk5zn;%>~-NWB*8F6?V5JnXJ6TxQSDT)1!uvz&@{ zWz=T6z^x4|CG^2KY9w98X1uSsS6=5A;Ry{BZdiyLsDbf`4hZtFHjs>Czfu6v?@2T< zo8TZ>zP=3ZTW6Gcxeo7c5TJ5#7ExMtb{ApjT6BGWJl)Y=ENi0UhQmlj_^1 zY=_IgLAQre3PM{+8^94F)A1YN_KL!RSJX=Ym{m`;mkXs~i47Ke5@H%=%hvW;^1SVEC^d zVqQN2tPY}|ly%IaVdtzmdv9zG9)h69oq3^756?dgiyLM=(SSEY<-x!eb`;6$-GXz- zj;Tk_j_F6T&AlJ6c`iLj#dX}fyes-QP3MlZaYTn6-0|NS>*|nCYmJ{?2)>S!XPEL@ z7=C!|ItC+o{Xf98{-{22PPzAs+O)0<1se&DYoxK|BBcmqWf6;Yj^t@#K8j;J{zjhP zp@tP6&1-*n^#$bf+hfW1CX+p$-735DiK@G`W0$umPqKo}xySaN69=!!Bff(OzR2BP zl*jh^`q?BSH07XvRVw_Pp0J4Mb!zl&22}nv}j60F{Q4WFM2YuVK#I9Ap6WM(aTf8&w$x=UF(kp2M_z7Qj7r$ODYRm zcM|O^_^=594`Zx;fl?T`G_(q}nNY>tm#j?rIdo!glCl5J^vg$kNY&CH$nRDz(~HKfaLRQlt7w_)V-G(nYe4^r&zLc`PGpau9IIh62Jp$?@^Bqz1H z2>mqtJ)t8jzdX$Y9OX&e1+&paVXhV82J02@3(5tCOVjlAlw>&~4ws=<0d8T}J!6vLh zC%)$$QD)gD{O|<$*t~gzL?^Kp9rF65JClO>PCp^^=$hRX&)7swyl+ECZM1XQp-}Pa zw)F=Pp*U!2->q$N*3WoYw!`NIczaxYF(s7!WJ4f2@*Pt*66x=QflqVhOFtlkkES*? zE(c9e{Qhof_te&Db7+J;Xp7&+Ep~a=QTOzysbq8gKv{c4YC1RkHP9C-IZ;nYW!qTG z6SL-hM8&|}Pa!MOd?i0*|F5%zgP*3&Jvd81Joge5Y)Z7ET|u#7)J@aT3-1qrHa4QKH^4WoJGt@Ax}h%KnV^{eY#l-|4?T^)qr;nx+Y}ibg}&iG zs9POr*HfBJW&WXLXOgfu${iZNFV}*D`f;AhaY7@eLCg*W_0^admwLrds4=kw7JP#$ zXsXK2#7d=*$}~lbKCL(7Q_Ke!GNDm)&TjjlJf*xqV87`N$oe9@F z>D|wl#p_k`e;`eq>gK|F8fw*z#NQ!hh@ZW~X#YrgQ&f+vGq)G~PqUIy zWCTAVf+v61Rd<1_Ao(NJ4AH_aFstfnle#V_(Rz8-I2x}ufhUgHG=s2T#c)95ic-|i zC1o8LD;W%AM895+3tykrdl|OqW|S~wRR>87#Kx13W{(cg$!hqrl@ApT6h>nEWyDmveBDFY zgUVO}Wam5aKuZ4yw@o1*2nnEVES5(ed@tg`c6@bX^x+O6I{G#qD{&aQ;# z2V3(??eWguli!H-!}xFAlSxVK;=9IYR$WF^tV2RCgBTP%4Gi0%Faesg5z5t{E@^n- z_Di2GxqL9(RpKtqKTw3~iNf`l;rEap%_4ArB=^XUekB_djeUR=ZN4IxzN9k_M=;R- z)l=KFxs98Nk`EG)&=Vdf2h)LV*$@@-{c>ErpEjM9AI!^$5Zu9g^7mW4m;2c!PhM&S zUwY=LQnw9~c4lqb`2%3DQA-%mdxUQg?ZK>C+8|u0Yb`aL478KqK>T5g(3%sNXH^)8 z5ywkf)3mB*ys7fG2_!c{~?W9*-DTn0m51R|07kW*y;cc*IHY)t( zDhu|m80L@S@fgD+7+;L}N>-!ZXHm}_rt&9nCXkeHknSn|w=yvAiW`{mnE>g9cas2m zN&N!_@161$l_s_i9eb^Q^*ej4GoElR@bbq47$(;T#E10LgLwhwHd4x54LFZBv6LGW`lI}p1gS= z;XV!ZWJWuDr2`Ofrfe1Eqzzhj0sR<)Gj1JNsk!l__aB7Yk&s-aJ~#ur z*4fLM3sz4!`+t{|p4C6O*59>7Gyxc*M`@LUUa0$J?m2_sQPGcBHL5`P(-(GwZUD67 zXZKv;7hKn}vAD`7qQug(3)?3W^&)V+NA_6nQu@YCJCBvR<-a-;I2{-QRSlI()5WXq zGCgj7Jr9M5D1qchoXf~&y|OXkEBMY>osn|!!>iUqmR73W{NL-C+1!$Bwg(pwIukw; zD6KR%>LEr>I5RoF_aV4@Ofxee+#sxnb%92Z`0xs~5Mlc)iuIa$HieeDstlCIA8tdx z%Z=ar>!(EQ)*5r(Hsq}u&Miz772&7$5TtkL-CiScgnv1O{3 zhx(F#u*+rMSAxSu6l|<3p77@ziTqZxv2{)7xL#x@|k|Dqdq4PlJOr#R1w9lok}O8m(>+=#M7OI(~#F7xku`|x`w@*8-z zz4-nDrR$pbR#C+wZa}VW?i*#$UBWEJ#SJr-Z~K;FUE2<3kPJ`w;|C0JTdcgl%2oPa z?Ir*6O4H3i{-;C|7)zq@C@ouWYv%j)bRL){rGirc=w$kR9uB-CBIoy7@Vtg&B=$Ty(Co2iJ4)Z|A zxE^Rj@vftd_L_zxIzVYtHW0YD$F&(Wf@?2JnKflCUL!M5U;}zGR{5dAEBx~xmINGB z)#+r}M`LxEyMMI?H5}u>=N;ga;88nYDc%xt$;k$#C~yz|z8tbPu=!%ei#0&8W~}C^ ztJyhe?W8OKeGI3Ex*I`)xv;wHQV}(74(W$C4teC3X@i0Y)^Kz=BkreAvC55tNL69{ z_OKC5QGsT8;eflr#;IiQaAg2iiNJVXU;LjPijuyAE^e@I>>Zn|{VGWV&q#Z8wqpk9 zHUWJ7yk8^=BMRmhP$9?nU@V*wbG@`{Y$4d|M%85H8oYEZKC(o7*yB5jgMf`0qUz4fZSieT~`-?e?N_Sx8TaY5?)d44PhGTYCE8-15lyL?>^Nztg zz49Cxw_F(;AM?w^O%8PvN6Z^;HwB>f^&2=HnvX(_wCtmaijSfU;g0nx;N-%FZ_)V6m0p6 z%JpyfUEsb#-9ca{UFn0&6vIk5PwN2Ezi`=yFMLDCP zn5>s)*mGoRuSEsp9FT}s1D+V`BaHwy9z==SO^W*B!1PxFDc~LQ|9~2IxuF|Vs?DCH`K;}{kwq~j~9+|BvLjyZ$Kk*m^?Y!=r)j6~l?fsP|lF}aV^6l~O zG5_+@6n7lRx?H;DdV?91XVZjlNgwl6cW2I>#UpL|YUID;z7CF>z#X_yp;sXh2fbcr zVs2Z7wd?FnYx$&M8aah!=gKj`oAYIQ8b+1I-CV5aMvW?`o5>;chWsxS{gFD4xd zxA@5S|6I1cd)cOe^dKP8PAN$N1ns_9pe*1((xlRW3QG8QQgtNQ_VsgER{>rI4!Tn| z6=tLf`c@)1!ENR`mE-)eo8|rh^i5&xqFf6-cgp>z^%pO@yHMY@Fvu@6;Sd}ywN(Yv zn8b=@dhQH}E^-BJ!j1c|%bWqcaUAOq7ImjqgdV-ClW8gKdQ_`8>01U4`Bm}S%kBw) zD1Bj-%7Tu&OZD8#N&k_<3uYX?*nz8lah1|y`puJ{M#b^(*+(W3MtS5mjd7!Wf}!<< z))z0Smx~SBzNR$^EU)-l6YGyN*>>_D=?GmeZv$*$)nG(1uHT}*p^U}X0=CQxYHH?N z_lF|Yv8kN9uUE?rLp^P|NgEm1bS_5#x%aS18^gawk=2)Wxc9H8xeLLGUS*nwQXIW# zb9mAtIeEAQ;(f;vrRY(feu$rt6pcT5&={z*s1nVT%7MWW*Y!+R;0zAw1quQp z*zSW5x{Czy-;i2{0Uf9*jTFgI#72t&R}x5H49-XLM4xp_9SqS!5-B?-5%j%_!*G_B;0}}p;EF8$KTu@c<3Y! z=%H9KrtN_>kzPB!>BAkjiziK*zp^qJiwuztz7j0KA3YWxV{g=6F+Y~7(VeVHDrj-Z zcG_&%i%8?Uc&M((3t|zPCA4?iS6q}%|52xX;)Ivwz*3txw$zqqX77S5!alcX|Gj+4 zV5Y%^kaKwf3>W5BY4?>SZv|bKQ)<~0ve6F`ShN$_E1kf{)m2lHqIUxW(}~eo^I;_x zGCCKXYyi5n&-$__L|p%KYPdfkL~wQ^{nl@0HRq7lxsh(TVQ3oaykCu$2oIB41U;Ip zdSS8~l|?$&;v#OUQxvgk@+#GpF|b(~+74%-rgka{k>lfuTo{YLK1-m?|@C32)QDrjAR_E*t5?#O-EP-J$-RfH-=ttJlb&c z!$kL}3Z2Txz@95dqSi{mHm;uhipC3d9?}d6(K%6mr7gO1rmgROYr=Ob41LHM&QU#Z z(B~agSmC^O_^3_Grs$`^qySz}JAw12P*aNbE1i!7&7NumEmjm)$+_XUKq$KsbeFTP z!*YA*-3iSN29Zi5 zcz0kA*oc2Vin!vTAo&oj@x0+eGRNZFI#gQmi(c#~$wL3&=!SO>g#ZDmfJvTfmP*E~ zqXjr1et@n85L079)6~}oX$w2eF4XgpM^7@g{677@Jsr=oVDL&oiX;3`P7}ytK%Sh( zH?Qm}d%vh7dN?>a`32(P*auEY5010R${f+%8Rmu#A7e-ztW0166@{(wqymM;OX;?0 zZkf(er%%lmqn7Qs0u_ot(W*k!ni?czml%jDUx z*;r+9>r8Ovr>lh`x5}s<+Jh#u6OsV@0U}b6lC~O2O#~QKO)%R)nzy5x4Te_S+Q_t$J`GfoUt=877g@Ji-16NhVfDZD>v-xm<7^6k|PlgMKQUl*#k zRlkD&T;k-_dQ9MunnyjGFixRF?3Wp}d`EtNoZnIqoE6+>9oNXzKOIyf2GY=R8^na5 zP^-BP#ZWXE{J{7`&iP6+RkVG=_l7(}p4zad&MF+nvh$0qIJS$pR=nnlJ&TPAgJ&a0 zN#2^t4qHs*EU7XUdJU!DqcE=6k1aUas6J}vq>Joovyf{?|84%6TIGx&sg$@Y+ab^h zGWee`Y=Lnh^9KU~8G-;wHtEAlzG|jRzorF+Nrr3u34B1yeI#0b2*o(G;whOl6Ph1S zWj*&k_Ygf?zgKaAOz+8{=5Uj>WrvZ6aljjk+ZWN^9Ahv4%c+o>ke|*sK^UhflcA^j`5PFyql8Onh;- zX|@Wht_-c1%v>B|{0I8Gv$^U0d>X#?+jaLjKlF8+z-Q1`=)KO~!H0%0caDahDoxhy z2c0>q2I{&vFcx?@cDv&kOq z)BB-dVfK$oB2zAID;sz#oTd7XCaX=|9n{jg{lYj@OjlhnHQ&v{xP!N~F%BKQ9=6;q z9^#x-hf-MzHb0njhZgO{kioGw@KGyut9A;Y^4N%WvBS5+F})x-i?ZXe^qA7BGfjs8 zNEJO|I_jGC%fqdbm|Z~aSY>6EfBz%&r-H7RLTaIYOWuS7{VY$3=KgiUC{*1yp0d!j z?%t=&UZYkf~XEGTPf&A zFp^{x1Pxe9L?+}5gh1?}VDqu;=r31`M+3DaS^h(3Tw15s0Ky|O$rMHAl$i{TUPI;A zsK$GS!*Z@7DSX8_8Dh>n(vSrs1#ngT3cMlYxa8tQKZ^_me~|x)N}i9)*GjPDsb)90 z8cgpVFzDWZI^X-D|ec&LaHAY2!p>!+!w@Z2NKe7Zk&}XAf&XZ5&9qiqpqFoI0) z+TmgL*G2MFO5ucIH#`{1vY*19r4_GwVr!4jA-d0no6~&oEL!?let*UT;hv~3z})818R6QAuGjGdk*AHaKiLF1-dq?wnMS)w+uj@v9$wLv{kwji<Zq48o}8@)+_u{fKlQX7B?!ReXvPc1iAQSnwQiiR$Mptl_jE^F#k&S(Hhr z#v$3^tn5HV!_>tTvc#mb!YkG+*qt*9Z_HzAa*;bF#H0r1oP45mM*D?gY{x_x!Q#l|*{>yZk$wqwy$y;smI3=zOa5XLaShT6}DwyT#oE(Bb*{ysB&CFMYI*6*#vnIHjId#}!3iQ44Sb{y z8%_Aow6mDU_)S#Z8?DU;PXoX_w&RBT>voslDV^jRDKxzf#go)_Psq$u4_*tOwPw*Q zf+I)J;%7_9)bnT&p$8w-60@mxoRy~DAO>qL;|Opl2Y;Sx=h9|{BQ9^mqub}}7afP; zHp;nHXq#)xXR>n06mqEFQ(WwAnvKoA<+9O?uechVzDdOEhk;j~bYHMuIh&x;KrN5E zmLD_1<+r!WV-S+m8LS77>(eLYQt;eP3_3Kb05JXxA6?G*s2NjWpicV?j?{F{K7o+x9%qbT26$~l_ z8QNc2tOZmwatdQKdi?3P8YKZU6X`SJs%{DWGh;Cx__r#HzYAZ=n?EY;_c33wueQ)e zI7IJ(p9sf;4*!#pOh*_FG@1fCsh9y@ouz-@9na?olQVG)R0@~$W_*MVPEX|eBw%%( z|DnB{7Xs88y<81Tt_rvpw%cW*+mPTV29mC!5cYkK~h) zn?k;V{vJE;0tdN1*GexVK6!qaAZbwtxHrq5#NgA%0*_}UGxl!~XHBEAc|8F7MUkeE zpJ)pFf<=JfJ2jJNgGiJF4X1eCX9~Y?UhpH2xEI#1OVlVmnLMP~6V{2YY-5et6B!wO zi3X(3f+V8S)uqRdFu|4i6W&;Zo3PN2`VpbSFw&-J1l+zk1d5M{5eH{6oKPZnF&?49 zhj_~mbFOdd?~IZ7PNUyi-v}!p^=CFgyAk)hgZ=cvfp6j5uwO<+7F|frx zqQ~2(bMV|=kVaJS*u&cwpRir`0KNI=B^VbNLpZr3`~86pWXKTCy%zBTF;M>5)Lx<% zs~2UgFJ-UwcPxA?EV7?1is=2MZ7{4cV%0SphBp4eSpeAo?9?cmpS8C z4Bqx(UXh5PVnSX?LtfDg)~Sn-@{>fAU*x&pZ$SeRW&@{(y8Dx@Kd*4VKWsiOc)!D@ z`=rkt&OSD9zvJ+p9&XM*e0aZmr-9vLp+lkh*Z7LFZ>tXpF5MBJ@FDN~gCe%?GOX%_ zju%insk8cUZ$^%CA;kM#H@!o`KV$Ww$Ho6= zXJO4br)F`@Iwx-)@-*ly=tA^#paf0=tCEpj@3eDlHdF_|`rXOw$|;4V)j762Os;o$ zN~(cHn8PqDo{N`z5bnl;BgPUc_}ZBvv&WuuwV)+#5zHHXZu`>$+SOeN3({Vhy3`^9 z$GDWzoQ#zvT+ro=O%dyXMmIk?6rFKi0);k6vpUjPKE<+770oPDvoO+GPc^@LNUO7a zacCZ1HP{G{rx$ZWp5$m4Kwyeawf9UFWSR?)R9oD$&M7!=i{vO5GG-WF?ilut*|Pxm zn_eE4tkgWhTq=~rYUwO5vd-Gv$FFpcTaB@%_s!&9LAZ%}pf~HfHVw<5ICq;9UgWSY zj1-AuLPro6{p!U940afS6@92MCUjVF>$i{K;6OkG%8P@8Bd5i!hJ&H^xV1EG`pMmZ z0bKEu@Y^5o$`e}D*~X295bLqQFRcu*t;5SqdFHc|@i^Xbv#XZkl-zXQhU{=FyUQ}Ch=j3d0<6LQB ze*xCl&#fym*fJ=i+ge`M&qvbWp!Bt_ZEWp!n#VN`s%&g8s;wP1VhZX?E2mZ#fBr*< z3SDN_S-;TUFjcI%nwpYlP*0a;>~1c~@Lj+tppz+ML_oQrvp@ z#V9uNVz`o~sxAHNU7k|yB^mi1p)?h-`Q-x_6$e`@EKxr;B7%!zq$ewzOnxW>h0|Ex z+0zotipb_T3Ewrb1m9?e=%kA%+p$vgHr&6c%CWqtEJzD`xU_8dZ;2R^V9G7$Di%25 z;Iy-mo2aR%v;I$PI5WNZ#(TN=TX{oYEgqyQ3s>3>mjY|EJd-t8uy@3TnkiYNG{+)p zU6@1aIA6}%uO_6S7K$hOGwZiHVygu+4M{ZZ5k*_dKUUnzR*%+}mvcwnzt#U*412c} ze~~FPy;UNbI#~ppdUMH4DqBl$GXj0r(k4XVax8)s@HQV7}gh@ zYAq|tP_IOi*bp#Fn{5@~B<{<$wbm7)sM@|Y+$_kY%NUYqPRvnyOYdS^iH`MMy5^yU zM;zuT3VzSEy?@N4%B&y#8V>7#kvc$MNAwU=gPXitPc`XuBAv~qg7D*j!@3Zm9@0#0*cPk}lrmcmKo*7~e$309U*N*gJ z2&@%$6xz$8u+?q{5E7)htZiPyoI*cicPgd?mFl{OhRBZh7K~{~#_<8$GOoYJGYi4yC*T368^UILl4PVMmy z*>2Hn*U*c6k&nai`JR24JNvY!6lntz%wQs!%^WnuXf=E-1B|iUSq8I^M$c17qcOC* zq5||r5YTugHovo}(ZD6WbGK5(f!Cpm!SThMza!n?&6kuXjCs^UIZMu*=HuI$WJa!j zh2=*R{w{oJBoFc!obGeDJD6z~JtH4K@j$B(;N1%%Bf{o>Fz_7Q-mNF`UE51tB*Cyt zqEQ#{NY!PG0jGRbRv+-qk+I8v^?8-IuM*rD3}4Z%L6d#vxtyON#7vJGS}3(S6vFzd zn0DJf6L9ZY6K*W8W`i!{a74%F(u4u*p3we&Vs~^FtnaW>WZXpmx8tEpRgc&+=t4`< z!E}7_6bc9f0PM&48&Hr@7WtwcP)j}UB-1U@|9{r z*eADx`|3!3XMK4%MdK~}Q@nf%*WG4V!&eNxdH2t0%aO4r1j<8l!X);q_23^3%jj^n z`CV@109>j?y~U3$uf=U)TbdMFVQrJb#UWUEdf8%BNP*q>+{g(C*m)xT4f|K@bBsuv6YR<{ zv}XV21gW=ddCCuudtFucVp7VcEUly)>6uxKe{OPG^QtuQSBl%M>9ecr&4c8|{Vk=i z_d88tWL>1Vy1YbBa#j^4bl^z$H$dGCrP*avD7o#pvzpsQdiAk#KTgg&ykr_F8&3v( zLIV~W1}j4u;IcugjpX1nSHsw_qNff^f3_RshO%;RNH_e|;ad)35X^a|>wJT{8U&Z( zDku7Ej5|}T{KVwCM|;LHjTya8FvGft8po?93{JSG`oW5nK3Dky^@n#-&rwn~I4Zs} z>0p)578dHQ6RpO>mR&0(Sbl_p0yXyir5Om6qQNZdh)vwU^7x1d|7$Z}+kc)&9yNEX z)NIGaFmEJkK5Hd|k&OQcizk9T>+xzI(n)31bgS1X%#fd?c=FHew6VFOr; zf^ko~=VxQwhpC8W+IBt~(!P#p)0JS5U9hvV_j&D~@Pw|a00-XiU-FO)*$$ct2NHSd zNYs8OB=Por`i-Q)CS`+IDNYZ&5?Z(E<$`F@E>^-=mmM4~UR#=pwoO{9rCSIRtO8PlLX$<1Qo$5=$(ZVOQn5d@O%4O%{LOD+<>RYln zllB~2hd32eCyZva-q8%Pc3P}b<`B7HU~z?#_8o6Ce>OdOHGL#k`L&b0_Dle1M>(a< z`VKRU<7jAP*P!uwFl!=RaA;CZvaf=`;r$(*=Ft3M;!BxlRxh~hP|vkG3H46W)o;kR z<{oTUH1m217W^4-@6K|0baIIW)fMrI&>Gr;eW_0CiI8>2bEzN9(O@3DHGR#zifHXa zSjDw!kNZq<-Vw-wdnqdZr)LqMAA7>SL>^v7t#o_TQp`i3N6T4hKU%*e+KgR>^Q&r@ zEb0fV&h0OJOp9%D6c(hrI#0D)(T$SCAsA5NKIeGW-9~Te?gG>MD(Da3+B`tmGvB0} znVeOgk=}N;1nYQanG1||&qgTsTt-1S%f+Zc3VVY3D=QG((#W~Vl_v=>Ws>a?R`{?b zwX9KrtIBnBR5VAWulmum+^D9%l+<;JZyV}(%w<*K&Qw%MOh*xftOM|cVwIMnjK5_@MSq304WYmX?kBqHb{ zxW9h7LGrX3@ETNc-_8Xbhq^5LcS(b{Mz2R=jeS>$ny=)_y+7{@CIS!Ul1B( zcYQyE+`)~{V3Gd0O~!#2_!Yx#>m9e$w9&bHYG6;|6q>*}=*X&>(DiVhRoAhJx1BPJ z3qLYvq%_wph}V(0Kk$n|3=@i7V)$iRa*6l-7%nZZ)*(QAhWr3X#6luty3wB*%QKu( z`e(mxw*$ER_YPvO{_E=hOf=invJM5TT15Q7#bx=KSB}lPs&{E0yd}nI!?b|#L_ADr zJPQBx!$%d(axEA69l=Q$e{qOJOqae>>A_oitY74YG_yMzpI1C;w`E#a`5g`EW@dE& zIlbP;sg#Q20udU3qG&1(8ixXZQufIlsw>s#Kt){1P$->yFI&qzIbk#0ecgf3UIUxs6Fp~;%VUM&^KdZqn25?)<7n!HLN$K zCzDe;a4IDCUr7i%T?iGsNN7jBTHtneg10845dcpj_bLY9N|N$*CC<4JEmVxO(!%^# z)5)FWTz8d4a+Po-CM?U;TcZRqFsf+No~yT8T(xEx<$Y(7!-to`+9h?PWtH(Ym~f{u zGjXX%8(X9`F?WM_^|tGfVZFfd*yDqz{;8wYgtf=n7s6g@i?GK|^MVedMxx5EcrBfT$)^I#s8WY>2AjGqjNm+UOj2`oYetjo_1TSC-6V;qu_jP4|;m)^L%_{ zcf+}(zL?g6KiCcWSjId|GiM00&emXS^WuWkcX(nK#jces9jJYY58XBkte+;;U&R+> z!M*?M%DR_>WiJ>?eme*ZHtC0Hdo`S7>U-mym!uag7tJ0zzfv#C#*5ZKXPZOfj@bz9 z$_)W?v-m^{frGy0XD!>d-e*&#|8y7V@@%x3IC>scem%_?o^z)=tcFwII3$t?(hG{_ zW#QBhhrLjDXx2hvq_!(Lundh3Da-qABIg~Czkv>Tz zwT;FLdUKt*X=2XdGY{D{6J+>>RnbCivu$M-ka4!k6np$v)c~oIBpBUlia2Y*Da47W zINGM9g2^H;snCl1q?HW;bm_xz658Rb_GEY6Eu$l+)`L^r5-(WM=}UsKIW|?UAu3?p zsv6w`w>tm}cc1Y-_y+SCdtcuvkFpha-~TRvgb*ERPm=Mqb9|SFUjuCe-bs!>CeA5p zgSeBxQ8yTSA0?3R)FjMPm)|HtF;cP2VN8Ag36slcP_8VU{_Cs10J-xYLI;iJ?kkJ0jRIaumPB?nAWYtTTqvd-<;c_Xt+ZQ`og*X2et<9N0PzK zDXGt)PMSCpcj&P_^{c=4=bh<#qJBC_OSWkx3N!VH#tr3JUE{weIbC`!XV6aj`9_J+ zHDyd!Lk$FvO$&Y(fb@JZ%DBZkG3F$8LLK_-R?yfeg-S~^CE)x3JUmb{W}CVd39>7hh)7%U4QNEIB~khc86zs@g4J4WT)X>GdGN_=t>~}b#xciEAZq`w zi1U>U<-4Hv_791d2&bfDFS?cr)X9H61*=GL+OyWe^H6?nlo72DUt z(f`UnuN8(7w1fnZb#jhzGtRAnbx#G}^;FO5mM8u*U-LF;F!@yL z=u22GAo!qDQFFzz+}d_WRc#>*?-kPOI--8kV+r$&&D%y_kW(4cvq4MAS^(}xssHY@y)X_3oIn& zhMuj(HDfKfq%MO}0CBF6r86@78fK_{X_R*sTBtx8-#i_2&wQeO=-E=-BW_I1F#G3_ zXAVYf+W-P9y{QFNjK&xz@4Q+@t$VTbS4*5LK`9r{{E4BrOOP+O-qpm5SG9f^LbY<3 ze6?1Xj%GBxjuu|4P5NEUOIxg6`W+(Orco$g&8@F{AUsnF;Of{Zm$oPImuXP1dh)ss zkKdJz?m(bgBdn{2dF*M-k?EYnut#v2X%HE1(or}p)Yc$q6IP2{#6HxPIWm3@q64Fm zM9N#J6p8%Qi-a#D|HO{EQ0&t9ZwG`45j0l0rgNbu`Z0Pm8gtvK8`v=h9hISfgEtta zl0K+k%)W&oU^Gfi&kM?f%`kAfkERqemxO4m>kY=rtS@;-K_xus$umr+5TJ6;Z<;2E zq`d}b=sAs=7e0|(-`su(Q9itCYwiS!_*+BQ9jp|SdgeeFlG}TaWh@TqSHzqdww^zj zI&y~A zv3hX%z>HgwW39hS}aD4JbU6RM`iotmZ5?O*8Vg5Vd@wRn_+BPiwD z?(h=YCXwun@ml#tuAG*}h<}k?_UKuN)FU9304CaeJyn_Ru*jhyx{gAyZ>GfqQzNeR z2!}@GmERF`%wztb_wwW|A;tC(oFp-!xh}dtip0?4{~W7}yTIS`_YPHa{}Dwk)QkpM z5oy&#av8$Zq+HKew{;7satZh){P#{yR8?wK9F||&mm^RcF5|!mBdK1Tg1WaHZPbC-ehk0 zZ!=Z%dz&}u)v(u%J`e)3dXrCUa8W`JA|3ht16QjFQySO;_T)?dM>haybY)zMXDo?n@^Q+CEgRLP-5 zi!!7gI;r`PTnBroowWm&3==c9p5{-JQ+?GTFdkzNA}7BC$YRoLl?sY?NMJ*;IFA{k)A=$ zaMcMc2OjPsogOxCuf)#J>(S)(ZvnIS_shGk8a3h_TcYYw3AHi|BP8=noYvR<0ve`m zu^a)&Ft}%I#yw`DSM?cQQ=sX+q{}W7=?U@B`Vv%5h?{V~M>;}}hXzGxD9)(n@QM1n zmprZmcC@uEyE42XPinOYGtLh4i11eqJgkglK9Dh7k*0l~iIiyrdf1N1L;bXx^i)5( zdVo1xe#e9D7vwjAOCFV~=Zt*GEB?e>RP72eFfBrEqbDok#sJ=C1Mna=t01b{w#pIy z91)CViG#qi%@BzET)mv0TXn*JXXEUeWN@c3MM?7N8SkeXKK}QMyXf!85@x(*?IAHF zxZhH)z#NFu~^_sHnDSBM28+Yk zG}}twC&4g9k)tqU0B~W!jrk||E|q*_or7A$Q7`2FflS9EaC8a$wN^jlY8}Bv*H7v4 zJiMe9nchRfu<3$%v8y&reWk^*_riO$x_7qpOfH7ckbBj+s?2PoKxfYc%;inE_|qBdlIZ0YLQ zr3?!4bqeRW=q$(}D>Vy{k;;(KEW8=j4#DI|ZLb_LX7EFint46FwV-(?DKdOIOfO*F zqRtI3F)-_Cth1X)GU9}dd3>mxpY#te{l?bb6Prd2122p;_q`!#brt`>u9O)T zU2y9jdc$_k0Xr9Nu>*uF(x)DNm`@$Kfz;m6(7FZzbb1CM8@dKTe7ZA(PAikl=iZRH zZaq*;?b`|Sry>d-2QM@E0&0fw1REBk2`jDDy+-3v#(9GbnCT5OCIX;zyVO3I54w&Z z+BL1Cb5&HoD^*Gth!>J`J`q!FE_u|HcSMwDe4s!5fTUZjRV)TS|LOS?m(j%AROwEi z)Wt2NxTUQ@6E_bSZ_3>_0p}Nn!`qFqJt4C2?;!jyI_Hh8jvSmR<= zlnCEQNuw-r!!-TxFW97Yr1zE4-gLG3SAvb5ZQn3+a!7;?VdvFM58Q(Z>1S(CByNN5 z$dYl+8FjO#U?9HDpq;eX*+YVXOvjL@k5D6GtVQt2@(X7a$&)d4(=(Ziv{Xu00Nrzb z>o(l4)c1T%uOB?`AoR+FA*mBAK6}%_6_aK=cj1 zgqwAC{6@|oiBiE$NyLvU6A%Bkn61~N1#;!MV5wKqLplRd$QM|8ReeYLMF~uF#eq0Q za6&ftohB~da0a@z)et8ssk=wzmqSf5_eo7M^L|>9ZCoF_JH&-c8Ppe4_<^uFv18PD zkCajRv9R}ozKRz|v<|*$!y|}i{0?*ZZVzP;;4>zoAA!TD8UQxavpf_R?+;J#3u~`I ziMzFNqAOxwAZ46pY!qRcK6Q{(?GLM3;8G>x#S%Oa?#sD)Ph%!z+>_?Z8i6;-{$!#G z@7-;`R)8AfUUfLlDP7taBeUHX0M@;4CIjWN4uI@sGy&{i31fUyPjZLx$?!`hJ3 z2gOU|24S%RVk_x%j8T%UC?r#B)@VZ%}L?>v*5N*Bb7BpQnrxd3Ax zeVDC3S*<_WGnyfDTG6GA?*ub1uQF`yggOQ)FOVO@&=(?%u_nNkABM&`f?ZTeo+hl6 z6W(Cp`duUU=Zt1d26IQl1r*7PZb_mZkR`wiEk)6FC_It<@Z zQriAJR2a>ag$oQ0=29gm+CtWK5*%0X85Vd8(yKGM64SIKrpOpfO72sT+rKp=mox#g z)jS`ndnS!vS1;+1$3QS<+1d0Z8lLvGEb0Ux6iJ$HAb+i8DVKCPs zJTLHsS8@+7mnrT~I;_<0WNw|IDFD%ndlFHxu7|7!?kIc}8ofm9E4&4#QT}-=!U4Zh z{=Vz&hHS4IzB_mh`cm%wL$FpKtgVtLfNyb2IYdhgB8d z)g)@GZv8C$C^5vJGz_XWjm z`o;Jn7OD_6Or48pJej;L;xU74FCu!zoPF)6EX>ATrUGb#mus?%?wySQ~j%i=R9|cH% z*jfKV=z@lwB%;897c8g5&$!QR@oBfq0C#7pSs~TcTc;QM>E?IgEGItG!UH}N^j;y| z7^rXPqT4}^TCf$k)B8_qcOqr={iLJze%w%^I%QaN+ONLD{Uopwc))~de*40G?BB;w z_3Z+f8AK;s${q*f44$-|lKg)N1zmV1t-VS0mne*0>(Dx_y^Hc68)klNzH6`s4FeiA zw;Xi71iX&t%KxuuD@g`UPO`!m?dr2lSj_+;{tb;<)gbWo+{ThoUuxJJe7U?&*yo#W zwHo-swfoGPE%-w0TxugO??piQhs6E+D<=7j$+6;%sa^ZCEyWUU!d}qU%%P!e&TuIo zO~S((wwCAh5~k;eDF4$cZT8myB{CZxZV){LNP-cd;48@!xBai!|dRLvdS@C%5vzu3R1x0 zv*Ues(0KVa8~Y}U73}4*>S~b{^71C~oNI(Nj^oeCAlVkVb~(1)VC^`DI00@V!I7^x z(TIsvA!c>Rs#T%6XSaSc)*AyAe6F?qcIn34am`Ef3rZU7U-)n$Ili!d{1U9+OqAc> z@*m&viYDKmNad%reMN=z+h#XfWkGBpWNNgLG?OO@{4_a2n~L)GpExm+1-- zT#Cwr_z(rp6>U>3#orv^j{w=+DXU+?3-|q1@}Z&Y?4xFSIr1twqmgi{?SKQ$h50h=(>VMm3x}P9LY677NX6&uc)E z%7PIb*5(nvziyRNGB*JXfD`G1ApNVuJQ1^z(`-SWPbR#OA-6AfU8Bhzd7;nS2}XO_d46 z1&^36Ig2-;uC>5!u4`u$*0>O7+L1VukOo`K3FXH{G}?(LiP*;~;)2tKpX^gZ*dV(^ zUUg8E9Gm|`Qh5XDWqFgAIgJ(7n5C=S$7ol~r5T@Z`DvUB{5wzF z<;$vusEB$*J*K(I4^}T4f8ZDtt{RAsWS>54Aifw#KA~57P+lB-i_D^I(Dr$uo$Mr! zU+`D&?QCD2gP3vHVjJ+_1#@PEZA*~`okWp!%=V)O=f(+NT@G%VF728KZNi zfF}idoS4#e{aR?|>EA~e!k157yAUt7C+3R|umS$TW%B{Uzrm$H% zd$U=S)yass=zFtkJY=HB3Y>A&ws3jgjZl$1%f)^+0!{=wDaMD{kCK8^6oZr{qxDmp z>CW?UVs4ev7wO4Qy8imGsErF`1%gM5<1&gHxGJ2S^ER6qNnXFtSn49V%9?i$VsfIq zHYgriV;1JPM@&BAv{g2opT+IG=p1A#Fb~GqF!JF{rLKH!VE0Um%P==y-0?z-iI za-@zvPOhA+UC6XFqBWsj8|xc*Bg!A(xeNY6J+vxbK|xOF?mlyw&1PW%e16@b{gKs# zs%$SaS^49~UtSOtj!S6eDOdjZmUF-b!AnxzGHPNmYo`cZw0D*-RnB*^pIq;UlD!5b zldJTv(G6I0!S9PhMAChzo_mTi^Nxa-dGPviU0+zDR)#BV5D=VMqR6!Y?Bft!Mf!Q~ z@G`cMu&+k%3{6iNZuwxT-IOVr4CzYOVJ^~|9;(FQXTx%mzgQm3j%go5ZlZpgc_z|R z5vj_pI(6R;e9`++*iDZ%WN+lCzPbRMpZaD`|G;Mq9$6@jaJ}x8%)szMS?PRQBQM$$ zVWcV+Zx@Hy__+#1sBFL6U~Kf_?AZCz^+i`rqf&oWLxx%ir8lKa_A73;={wF*)S-p- zqJz$y6-5|#gy>8G-^Ff0eqRf;NUc$l=81|3i-z_07=m?wOuM!J*u<>Bc?PT8QJ%~C zrrxy-d}1<9Kn>hcTG(!{ant(j2pildNp9!fdqx+%wt=)cg?kWe$llxggD;-b?I^!R zIa3Nlg2oAIdE{m;Ql-`Z0Sg8oNGYWv0o-9?1>AC_GD0S%}T#ak<%mbL9qz_uYdm;Bl~}*R>uKNz7t1J Q|H}$W1LcGF-x@&v4^zkKmH+?% From 3bc712870db24f8f5fdc6cd181b2d66f71f02fb6 Mon Sep 17 00:00:00 2001 From: Greg Date: Thu, 5 Dec 2019 08:49:41 -0500 Subject: [PATCH 2/2] Improve handling of peripheral disconnections and some refactoring. --- Ble.jar | Bin 6983 -> 7134 bytes BlessedConnect.java | 15 +- ble.go | 5 + ble_android.go | 110 +- ble_darwin.go | 32 + jni_android.c | 8 + ns/exports.go | 12 + ns/main.go | 117383 ++++++++++++++++++++--------------------- nswrap.yaml | 1 + 9 files changed, 58492 insertions(+), 59074 deletions(-) diff --git a/Ble.jar b/Ble.jar index 88c38961337640615dbe5231e0c174a66976ec08..9b04446f4411766a8f9954dd63e1d212ea23949e 100644 GIT binary patch delta 5527 zcmZ9QWl$90x5kl%WtUFr2I+2;j-|Vl?(TF!I;Fci1nCxpr6reUL0ai<0k1mu-ud7A zz8`+`&UxmY^W~g5=NT6GE(latMnWb)Ku1SM;FSwc0*WC0g;MB0OjG{DIqhGh5WQgh zN68ng|5%I0nUeDY1LC9wm&17vGG+@)7GmTifNhoISd!C9!vv}A-ejf^Wg?5x+ez_C zb&|D64J){3-l$!1UKvUHlrw-uXQ`%pQ?tOgmJFzHY4QNi6*xTTrem#Z9`gD5nfNQa z*vkQ{@k)|DAc`EBEFlZaWHF z_Irj%29$4@V3b#Osj$0jGwKyDXf!R^J&Nt zYSs@!9~V4glZ`K&)WYiCz56*+=L)-%gZ?6!=ZfHufIN4;BH>Urf;K&NYQ!TpnmD)T zLy?q56{qiwZ!!1p?{gzu+yvtrBfPZv91D|&#DTXBRYj~!{6OsbvP~LFJ72c4)3dP6 z&>I{V`;=Ij1heL#piwtO*p9Q-NX62^nRqKHqexckqVyE6v7Ml3zFS1YjaAn5Dz@Uv zu$nj=g72YS!H=40uXPRMWgls3xWvc&o!UbHFMWz)<|~4f@hi%97O+1?d-R&M5Hif-mbG~IbO?CH zh2&Dw{1T18bJI`Wi&cyp60YY8qX73sU?gB3EPaUmxE*x+CDkdy@C75jd(+OVs)DH- z8&2|AuGOA4aptq65bEQWx)WkG5A0EKTE$ybyNW`llN7}?)X}G8PnV9W^Zu!w8^DX5 zZ57p$*QW$lB>M4AmArJ%PuS|pXy_T+Z`do45DQDJo(M>cc(TM+D-V%^< zF>8|YRM@R@YkR5*<=RT*3QQM3U~FO=u8BD}%oPx#9N8h{LHvm^Uan-Oa>ka=iO(K9 zx2N_@%|P}G?M|L_iUO5riN!JAF*7eWpyxF3=cLcc&rzijrh`knBN)%Pm&>0IKi6Qby75UPB-%Jeq|Hj_wG!rO!nL0fP~T5HHt`+(oufA zmwaH|m?pkBn`@K_CM0pW^mYjHyP{O#%O~@nEA~l<%DzvHueZ8cT8xf&b*HRLA`7*# z8x3fdO>ta-!pJ^#Iq0o3&hm`G;0B6vndoKKL)kF}QO{;ZS`UegRcx3kBYbFcOkcIHd%v;&ay ziZ~m%a@RncsJSf6K%ecFDq3l`lOa6PFeY3Rl#?G>R1zB`vlXzPctnB7o85Ijy|9*w zfl|z((DF9tT0Jd0019N>LBYk5-gEv~=BuStj7;pAAzn(q8lTqSL-EopeBRVri@yHD zcBf5X%kNqvHx*T)QPs4Q4QZ@ek<2(yhecVX=51BH?dp}IN`CS31gv)bc!hvToWd#| z+;-fFzXJiv3$VYwQ3K&rkEDTwOxm(8oOt3YwTz%ghsxc)#x&@6RcAjrm&9yJBSFzu0op1h zTn;HZlS2wrQxGTe)=cM0VEk;C+K0D62(>+LDGEH>@}5&{Q6~Uv{AMqM5Sm(!eQaxQ z8;%9j;)yzSX9Zm&>sU%l9)B?RmKPNlxntice3AEM2!n#9k*hQkTOqQU6tR^iVe>QJpG`5~vGiV* zg@^Jo7u=vN{1|K9=*ih^S|vX1$LP+PUrRIUy-|6%glp`@G^(%)+W{K_;Si<;PYpt^ zhF72qVT`*Ev`l(5+=D)x#OqCV=bTk{dIZ9jRP5KQ$~rliUCyog%t`-SZ)Ib$ ze$3Cf@Knhh<%mnZi40oN7l|F_69EJ?^Mk6(x-^=oR=B_>|Q zh>6NKNnFSz7#P-wB-7;|N9nM@)?4EMW#TS_#a4TtBe`QKBPT+Bni#`RF}jBf_AQ3+ zPVHlJ;;txW*zX=c-V~rh&lHHtC*bGv&)(bIfRhftyDy@rFX|P*US=XUBU}Ckfht7r zG6n^W^rBk0R#z`;Zu_>boR>;1*-_ zg$1FchHKLYBkdy}GdyRnO@YD_sPu$Nk_{x{&v*@}SYJw}g@@ z$+s-+>nNO*u0;fqI%3R{67;=~#`gaD-c(7K5SrLXZ7~Sz;jp&YNk6`?CQ)zd;AhM; zf_#pzpU>mi@^#K$5>NJdaEN_eS4t$dy!F9+f7;I@EJguIynLHFsLc9S_dF&>a_n4B zr@MU13k9NiZbJysIMaKLcd3J^HZdlW4r{z?n+|+2iWT zJECKOao<(QDw%>JJCVB20XHwff(4>^NpOHu&}FtMGl8SMqeGn}#3ZOPoazH&c!)2X zou>B})kNcLZFB-StFgM{x~ll>vZPhA&+AgH2oQ(k>RC3f;~W*!?ezla zv$7xtmR{{}8oCBLJb`4)=kkqHMEqGQM5F64N`dGkJ~}fItxJV8D*;oF2Mb-tGUx18 zrPx$av%O;^9gOClciE_jMwk_h@o%8VmFYviEV8eL5!Rv3S1ALrlg|; z7)VRJZv!V1!!S+O$6ai}(RfwGrtn}=fd`_PJbJaGsphH$6$pwv`FPL(f{cJ=%qe08 zQC=icVLW?wC6 z@0knGXu7XS@+`o~?;-tM`z)VS!q(LT>^C(j6dirAa?PP!xk6MuiLP^4F*H^g@H-yEG-Qh~#5)eA~sScc4{N=&t2c+D~3a#c4 zG2}tL(n+?yp{KTpMSZbfOd1Lo8v88wN1=ZGG1L<)Qww2aK= z#f*%&*adwy{2Hu7nA-6No(^~9bu;zK;DrGKjiI2ILk?)h{;&YzJj2RB1p$@~(!S>E z>WlJuGIRH~C%P2uy@q<+mPW4AX;P*hNCmb;s7c;)3;1;JWozU#u=9!q3WIHK_EdZRzkL{z>dOoX?`XHj03>DcGiKk{apW%pX|49X~lQ`}UlC7**(!{U!{XuVt_Bbek(Ti$LR6RLUyqINm zubxo(h&Q(rwf4zD&6Vim=L+-oP+jU{i{63ut!DKfb7K{L^d9<5SaXdvKoeWFn|Y((ObUdh6=r}(FboQ-rv3b=Dtivj;E z&w>^+6r5xw8ql?23eZ0g4;FKA#wPe&f>yn_92$7~rrl8Z?KD#SvD7lr(Yd40A z5mMW;2aqWuH$;MUs~jk{`I{2rnFs@O4fO1zf1;`mL&qMP8Dk;mGsRKnYF>Y}V# zP5)0q!3N@)$H&mzrv(WGIo`s?tFO_R1pUg45;v?Gq4uA`sA{;ejaZTZ8q!i=OGiUu zoY&6~KbzJzVvm=BJwRtQPF7He$$It}ltgPec1&EI{MW|F7nTy2IR1U|1EZMp%BFfi zk_Q$qp`#v-$=Em9AK=#X-CRZ$^&v04Q7`-+L;KWkr{M*n;+$Py@X-OEHj;IvpsZk- zL`LzC?<`0M{9n4!YWz5TLla_sYu+cZk~X9RX%yWqPYdS1s*@v_ono9GrZ+-!k12aM zz?;}a&8EN~-om9kVrAe=!M)&73Lu8_>Ut3GWQ_KpZ7xlbs~YE)V}o~o96>LFh6~8YkIgz~ z=)}rC!fdFvqkVJhE|K#N6l0BW$ypQLD5vD88Ftmf8QTUV$Yn|0C8}%Jxt6-}ixVoU zwn^)*mz#a6U;z?g*l_*WX!?d2CpMcCl^&&&!@}4fsdo^4+L}Qs9)Yt+G z&TI<)gla>Zs>}TB?p3lf85YQB*9)t%NxZU7Id%2yVvTnzBct&+gIN{#}BsdFiAHNUte;-9G0Wnz6gtt~n&#B@1eT>^f~Dx-M?2vdztpPd7}V!R(C z5u$)9LXu*%V6#W{Nk6ZzX?%p1If0xxytzjiiee0+q2B4Z(A{et-83%rD4L6bhZw7r z&s%{G5uxb{PngFmR*Q^UGf-EZ2g$#a`Yt{DbpQYXL5A$_p#B1p0O5bV%#=J5p?^lk z5{cwLl96)!qcSPaKL(Qu{9^~H2=I@;srJ9VNHUq+zknjyOGE>dlou#WDe+`j)PFVq zvl;wd3>Xmp^AMo_5mKitli~jp{%2xz|EWVT0R9nDrBDJmatlawmN4a#Psph%+=8i>kHNQ@>d4KKA-QV2Zu?HG^k4Fjg|K9G7 z3^yVBEJ~(Ar@afL2lu@f%(WyFp1MelUugW?-D3*86kOE*nG*g6C_rP4M5Q4ta&nm= zF;IaKr~whPz2boZE2&{7LjzcXA$)NdvGPkzQ1y#I7v(rzcj7h4${r&8xmj~oZV`un zyWZUVMkisW3H6A|LoPo3bvj@%pbxvsbSr3|uRKj&(aBJ3k=!H~@?7@Ikem;paxiw6BCGma78bTJddp16}d}WKQFDXv&N279&5M|;Jgm4rtwvEe(v=o?n z9wE!0rQM!tbIWSaOwjLD#U%a#pcDN0llIOQJztIX8*Cr(7eA3nL9AS~-m#l31b8{- zz0#VFdcg9vk{}!J5vT^qp9bt5r9x_+9}AQw!cSCvQ^_hUL!M45RkUMTr><$WEv%6V zn3M~b@fS(;crb`x99grK@Zpk$wA!E~^L^Edh`btCv^s^$iS_*@<7CsQqXdzB9TjBJla65cMeL-+S#3di*aOv1>?>tlsmT-8 z$*V%%q(Vev!hz-VLfKYaKJm@@y7;y;N-$LD2J1%Y;2CnZU${0vbGgyr-0I9B=vB(<{kAI#5TwQ(h3=V+0Klp9Kyu%E_$HK9Csb5> zzeJlLPX}D8-;|OolW1N1Myb@W9~^d--xNKRn^+IuaIZ-Wl$DjGXKMn^IA>4e++Aam zlu8Pc6~DX3&_Dq2#|RnV0@xTBrT~n8?*9oQ>fdnD(*kO;aD%b_U)m&*;WIBHI1A41 zr0YF6Tg02|4C=!42veGy#|R2iv>3bhaCzvreh!&FUKuYQw-uy`b9@my-t+NJMn&*~ z=|JR7u!N|(P9~a6Fl(#)CnfG)LskqH*YY--R2o=9` zXGdjF3|@|KQZFH!+4GSeB))=bRyQmC2US7Ne#CFT7p4lpSlUJl3oH?AePEVWzcTiW z`-}9(_&4$a-5uZY%=nH<<7eE5Y;6-y#g%f##!?BbtmVtCwi<_q8o2~ktDl%(%dGhf zB?Y9+k4o^2zJX`VGYJRi$}N5B7XXU6E?RyL>!sd$S;hIDsf+fp88XMuty{>;&`iz- z@+-1;h`>!m+dVp(gYX5x(_g#-A9;rbRy^gFxBQM=-rQ=f8LQ+5uR~MyW!#w4$b)`V z>U)Qr*1r`??#CL)jw)#7RvwD8L#UH%IPe}4<`mW1Hl=uvr&hO0ztoFbs%bjNAJsLq zvxvkcu0pIO@MWHv-69`SQi_Fj_FBIg<#&)RM{*^?->U8FdDTtT%xypAn6h-xR1yN? zm~>bD(5q(J!(59a7_e!wMDU3FMkj+9(dTxr|9pt3%2p8(R@^J-k8CM{pMGfS4t~l2 zw@AOvb?KAu^qPh0i?j@82l#iI)em%0ilaf8)J~xTK1nlc21s}`nwv$2sLsvA7Oq7s zftua8)iDCpKx0HQiUC^+Z0ZFt7RD@{+BOw2x{rl;GTcRw59%Id%j=kWE0+Xyu(V(jd+x5fNeT?7psiDiSFNGI8CWJi`wZ9BZAkE@QY8sR zYlgJd_J}9Xl56L?Qsx~qo$r(;Ac1k>vz4y13j^Gv+p1cVGvBR?8Wn+p1TjK}o9?k^ zJBwS$S1~)`^JDO~TbAu9z*t7+)UmSH!j4pw=UD65lID*w0935yUBt8x0QRlK!F{YQ zs67bOT$mVtvhewjBX=FQ$8PaQu7b?9E(j5gcgCfGk{sQJV{ofn(iekB27ph(lSA!% zF|b9CjO3I42#TG~WBiE--y4hw{AyL1=4o@}MR~3ZP*2_Ka>>JiH%Txz^$R2E02&^t z&XLii_(R=3nqyq+mOZ2Jz+4e=O5>@ZQRLWdF@Kekc#)~>jv$%fLb(o`;6h9@%9wQwbIvW3%gJl?Q%b8`XSSNo`UkbF zz!thjW8!6I#e?@5!~bqDvtbH?;%V7Wc77yuuZmY@)F2fP36uEJSuh+jLj>01ekkJ1em$5suP%bu8tD_ zk?(wo`$Jl=6n#g^ois*{rJ|HT!P&dKhrq@SakGZ27<)q8Is_)5bwTOrZkNE<)J zh$%C}I5V|Y@U2m`0`UeZ>`TPik&pxrv`jw6v(Iu(?Ii~oRy@*-Z52%M0d9>-8?2*seO=p*h=vD zZ8bv{|GOeUBJ=!;CQjPKoNL~S%Ba}bJi~96;O@jPcbwyCbO^;lv&wFrHN;m(PgE5| zOYtXe8KOZI!!t#$AYLD$LS86B_lS8qvpQCGwU~h)NBm%%dq8J@kBFTgDS#Nl^AamY zH-yRg%62{@xaWb2NUR=C|1|1&$h7{4u<)BP;xfdd=~brD99YcFY*@I>!v&Joy%X8D@rfPnZ*t&R0tv?IRN0 zhx~@{P35@ff2wkpBb~;6L6*25bvH=VFU^32HfWR=O^T#8=?j16wJ)m;kL`SMjUJ{? z%*L&<9mHK&>^>(xd=%R$wsUe{>y{&FM@yv5nXBUC8}55)`zWE;4XNI5H*mgECaLq< z@}o%b!iTW%Gfk#>*3W9_2w9loS|4j+1HA4rHX^UIy1-J^hu?Se^J##g z0Ur91++DTWiIxlQ7abRB9(|WbJi0D?l3!)JtwA#7npNOk9rwWB>f(hc{b5v%WRV5) zh{TsYf6%WrW;Dq76VifQa!_L#6n|VxLhqsf%v-nD-rF=Ro?Cog4o#_-&r9kB`O%HOGB1> zj0u*(X&KYiDly>=P(0mp>)^+#utq-Nif0RkGaHw}fRM~oB(71Wa9!@U?|^{t{}huXN4%7ND9qaZ3_2vTw#z9gVO=1U#W;<9`or3a?p61<~Rsxlggz#Dw=AgU}s@eG`+BE44!HB zElzvqk&>llp5>E#6YJbFBOAl_dC(KbR(?1#X)BcU1ShC9?!_izVvIAEDk1MlQq$*V zs?tXqLc#e&53DY2F|lXfer&fZaB&faoO?!AdX=#DzTcl;BSQ3&iS5kd@#JW#jn)>BUIv%7}z-sZ{EW3LZ=9QH8k#lRoFyQ6B5kHv;M&Brm;< zsP)yxSBVci)Y;b31tw?!9(9hAFAIG+Vd>8-N1nhGzZt>HpjozR-%Lyb#@7mS1ZcD~ zc`>fr4Z$%slcG+(B_L2uw&lPO`eF#hVx54rBM=s~>Lc4F${f*Qxm@;r?gDeNM+vZN zwU>6Mhrr+Td*1|VDeO#>RTP#uYMu&=2N1b=^eOY}v$=f%4VLc{dTmV@wg^?$x+wK0 zN^IElOf*!MJ-hUI4m(}49EM-da&E|d_cuBQwwRY=(3T3Dvq8r2q}Qb0y7fyHdUGKW zR;hrX^OIk=S>2xKPZxNNR$Az0gtg<=hd0#UHd9^|_Vf2lhgDYLab4_%ETL8suo5a5 zqtVMG5x+19#AXlo6iIhW%PB7{>2}v&x8*Yy@O-fE!eINd@(g(=&Hi14!%8HkQQ!$u zkp>NW(czz^6mRB$<}B_?Pg8xv76?YheAkp7k&Z#Pki726V&QAcG1hR$K#7@b-a=WU zN_N}6>?jY-MrkGNduGih9cD1pvhtxqA!7Mw@G6p;8_iAXj=i=mNhO8%&Xw-n@pcs5 za%^Vxc4L8}ToEMCG!uAKHsk~oACptZOpD+oep?>8VBst3-8DVT$PB$z(_u%h8S1*> zuiGUb9fVpe0FCc+V%uG|@&$_D^0DO&^zbMwzZ%kVZV#@A@oDPM8knd~naqDw=&}TJ zUHYN-3^usQu8GdRc-`Pd_A2PL$%JdMLC^rcIb`IgtvX)SoNU&Ml$&f0HVs{}Q_snK zK_?kc8>Ie$=2Gm+=K3^O zR+EOww*9!RQGtGjE$M+eQTLsJ$3(00d&xfuRi&}At4pn=)IhcsO9_)m9M8Pu_hDFG zc`mte>qQ?XcSn>gG@BeTYz`z(9Q2NfPVDs-TJH7O_Z~Qvk1lVy2 zmgtQ0hhVdq9B&mI`9_yl z`d6E?n}~A-Epb>J8tz1<3UlO1sM3s%CFRId=UDc5=X~OYCb#u>U-6HQK4X&*JK6nC z!GFsl`TE!|8A`S)&h%CAdd@R-%g9Acb4psY_8mPin z`UV_?Po6eW9gh7zE-VycF2N9!t;=SI( zPS&gwQ{@=Z&9@|5mt-b(?|3cYA6~ZC5Am+3ZCw)F2&vFDBBM`AveTV#LAMkPX%5dh zmBQqr--RV|juT|eTK6#?*3M&YB(Ma)Kt=gB22b-k*6F2}m8xH|rl&ZtISsYE2}iL zSerN~DE^awya)M{f1Cby^T)to#rW^}1VCxf3jA&Q@3)x$+k>%A^v`RIs4iMCUOd&m GmHz?#rw6kD diff --git a/BlessedConnect.java b/BlessedConnect.java index eb49268..bbd1ed6 100644 --- a/BlessedConnect.java +++ b/BlessedConnect.java @@ -94,19 +94,26 @@ public class BlessedConnect extends Fragment { @Override public void onConnectedPeripheral(BluetoothPeripheral peripheral) { - Log.d("gio", "BlessedConnect: Connected to " + peripheral.getName()); - Log.d("gio", "BlessedConnect: Address = " + peripheral.getAddress()); - onConnect(peripheral, peripheral.getAddress()); + if (peripheral.getState() == peripheral.STATE_CONNECTED) { + Log.d("gio", "BlessedConnect: Connected to " + peripheral.getName()); + Log.d("gio", "BlessedConnect: Address = " + peripheral.getAddress()); + + onConnect(peripheral, peripheral.getAddress()); + } else { + onDisconnect(peripheral, peripheral.getAddress()); + } } @Override public void onConnectionFailed(BluetoothPeripheral peripheral, int status) { Log.d("gio", "BlessedConnect: onConnectionFailed()"); + onDisconnect(peripheral, peripheral.getAddress()); } @Override public void onDisconnectedPeripheral(BluetoothPeripheral peripheral, int status) { Log.d("gio", "BlessedConnect: Disconnected"); + onDisconnect(peripheral, peripheral.getAddress()); } @Override @@ -178,6 +185,7 @@ public class BlessedConnect extends Fragment { } Log.d("gio","BlessedConnect: disconnect"); peripheral.cancelConnection(); + onDisconnect(peripheral, peripheral.getAddress()); } public void discoverServices(BluetoothPeripheral peripheral) { @@ -260,6 +268,7 @@ public class BlessedConnect extends Fragment { static private native void updateState(int s); static private native void onScan(String name, String id, int rssi, BluetoothPeripheral peripheral); static private native void onConnect(BluetoothPeripheral peripheral, String id); + static private native void onDisconnect(BluetoothPeripheral peripheral, String id); static private native void onDiscoverService(String id, String uuid, BluetoothGattService serv); static private native void onDiscoverCharacteristic(String id, String suuid, BluetoothGattService serv, String cuuid, BluetoothGattCharacteristic chr); static private native void characteristicChanged(String id, String cuuid, BluetoothGattCharacteristic chr, byte[] value, int length); diff --git a/ble.go b/ble.go index ba352ec..6b02927 100644 --- a/ble.go +++ b/ble.go @@ -130,6 +130,11 @@ type UpdateValueEvent struct { type ConnectEvent struct { Peripheral Peripheral } + +type DisconnectEvent struct { + Peripheral Peripheral +} + type ConnectTimeoutEvent struct { Peripheral Peripheral } diff --git a/ble_android.go b/ble_android.go index fff5776..ca39f74 100644 --- a/ble_android.go +++ b/ble_android.go @@ -277,24 +277,7 @@ func goOnScan(cname, cid *C.char, rssi C.int, dev C.jobject) { func goOnConnect(p C.jobject, cid *C.char) { id := C.GoString(cid) - var peripheral Peripheral - found := false - - gBLE.peripherals.Lock() - for n, item := range gBLE.peripherals.items { - if item.p.Identifier == id { - peripheral = item.p - peripheral.peripheral = p - gBLE.peripherals.items[n].p = peripheral - found = true - break - } - } - gBLE.peripherals.Unlock() - - if !found { - log.Printf("Go: peripheral not found!") - } + peripheral := gBLE.retrievePeripheral(id) if peripheral.peripheral == 0 { log.Printf("goOnConnect(): peripheral == null") @@ -305,27 +288,29 @@ func goOnConnect(p C.jobject, cid *C.char) { log.Printf("Go: goOnConnect returning\n") } +//export goOnDisconnect +func goOnDisconnect(p C.jobject, cid *C.char) { + id := C.GoString(cid) + + peripheral := gBLE.retrievePeripheral(id) + + if peripheral.peripheral == 0 { + log.Printf("goOnDisconnect(): peripheral == null") + } + + go func() { + gBLE.connections.UpdateState(peripheral, "cancel") + gBLE.events <- DisconnectEvent{peripheral} + }() + log.Printf("Go: goOnDisconnect returning\n") +} + //export goOnDiscoverService func goOnDiscoverService(cid, cuuid *C.char, serv C.jobject) { id := C.GoString(cid) uuid := C.GoString(cuuid) - var peripheral Peripheral - found := false - - gBLE.peripherals.Lock() - for _, item := range gBLE.peripherals.items { - if item.p.Identifier == id { - peripheral = item.p - found = true - break - } - } - gBLE.peripherals.Unlock() - - if !found { - log.Printf("Go: peripheral not found!") - } + peripheral := gBLE.retrievePeripheral(id) service := Service{ UUID: uuid, @@ -345,22 +330,7 @@ func goOnDiscoverCharacteristic(cid, csuuid *C.char, serv C.jobject, ccuuid *C.c cuuid := C.GoString(ccuuid) log.Printf("goOnDiscoverCharacteristic: %s", cuuid) - var peripheral Peripheral - found := false - - gBLE.peripherals.Lock() - for _, item := range gBLE.peripherals.items { - if item.p.Identifier == id { - peripheral = item.p - found = true - break - } - } - gBLE.peripherals.Unlock() - - if !found { - log.Printf("Go: peripheral not found!") - } + peripheral := gBLE.retrievePeripheral(id) service := Service{ UUID: suuid, @@ -385,23 +355,7 @@ func goOnCharacteristicChanged(cid, ccuuid *C.char, char C.jobject, cvalue *C.ch id := C.GoString(cid) cuuid := C.GoString(ccuuid) - var peripheral Peripheral - found := false - - gBLE.peripherals.Lock() - - for _, item := range gBLE.peripherals.items { - if item.p.Identifier == id { - peripheral = item.p - found = true - break - } - } - gBLE.peripherals.Unlock() - - if !found { - log.Printf("Go: peripheral not found!") - } + peripheral := gBLE.retrievePeripheral(id) characteristic := Characteristic{ UUID: cuuid, @@ -414,3 +368,25 @@ func goOnCharacteristicChanged(cid, ccuuid *C.char, char C.jobject, cvalue *C.ch Data: C.GoBytes(unsafe.Pointer(cvalue), length), } } + +// internal convenience functions + +func (b *BLE) retrievePeripheral(id string) Peripheral { + found := false + var peripheral Peripheral + + gBLE.peripherals.Lock() + for _, item := range gBLE.peripherals.items { + if item.p.Identifier == id { + peripheral = item.p + found = true + break + } + } + gBLE.peripherals.Unlock() + + if !found { + log.Printf("Go: peripheral not found!") + } + return peripheral +} diff --git a/ble_darwin.go b/ble_darwin.go index 396af9d..a06cf51 100644 --- a/ble_darwin.go +++ b/ble_darwin.go @@ -174,6 +174,7 @@ func NewBLE() *BLE { cd.CentralManagerDidUpdateStateCallback(didUpdateState) cd.CentralManagerDidDiscoverPeripheralCallback(didDiscoverPeripheral) cd.CentralManagerDidConnectPeripheralCallback(didConnectPeripheral) + cd.CentralManagerDidDisconnectPeripheralCallback(didDisconnectPeripheral) cd.PeripheralDidDiscoverServicesCallback(didDiscoverServices) cd.PeripheralDidDiscoverCharacteristicsForServiceCallback(didDiscoverCharacteristics) cd.PeripheralDidUpdateValueForCharacteristicCallback(didUpdateValue) @@ -281,6 +282,37 @@ func didConnectPeripheral(c *ns.CBCentralManager, p *ns.CBPeripheral) { fmt.Printf("Go: didConnectPeripheral returning\n") } +func didDisconnectPeripheral(c *ns.CBCentralManager, p *ns.CBPeripheral, e *ns.NSError) { + fmt.Printf("Did disconnect peripheral\n"); + b := cdLookup[c.Ptr()] + + uuidstring := p.Identifier().UUIDString().String() + peripheral := newPeripheral(p) + found := false + + b.peripherals.Lock() + for _, item := range b.peripherals.items { + if item.p.Identifier == uuidstring { + peripheral = item.p + found = true + break + } + } + b.peripherals.Unlock() + + if !found { + peripheral.Name = peripheralName(p) + if ok := b.peripherals.Add(peripheral); ok { + pdLookup[p.Ptr()] = b + } + } + + go func() { + b.connections.UpdateState(peripheral, "cancelled") + b.events <- DisconnectEvent{peripheral} + }() +} + func didDiscoverServices(p *ns.CBPeripheral, e *ns.NSError) { b := pdLookup[p.Ptr()] fmt.Printf("Did discover services\n") diff --git a/jni_android.c b/jni_android.c index 1b0e1a8..e50c218 100644 --- a/jni_android.c +++ b/jni_android.c @@ -104,6 +104,14 @@ Java_st_wow_git_ble_BlessedConnect_onConnect(JNIEnv *env, jclass class, jobject (*env)->ReleaseStringUTFChars(env, jid, id); } +void +Java_st_wow_git_ble_BlessedConnect_onDisconnect(JNIEnv *env, jclass class, jobject peripheral, jstring jid) { + const char* id = (*env)->GetStringUTFChars(env, jid, NULL); + jobject gperipheral = (*env)->NewGlobalRef(env, peripheral); + goOnDisconnect(gperipheral, id); + (*env)->ReleaseStringUTFChars(env, jid, id); +} + void Java_st_wow_git_ble_BlessedConnect_onDiscoverService(JNIEnv *env, jclass class, jstring jid, jstring juuid, jobject serv) { const char* id = (*env)->GetStringUTFChars(env, jid, NULL); diff --git a/ns/exports.go b/ns/exports.go index 6bd0715..4b0635b 100644 --- a/ns/exports.go +++ b/ns/exports.go @@ -38,6 +38,18 @@ func CBDelegateCentralManagerDidConnectPeripheral(o unsafe.Pointer, central unsa cb(a1, a2) } +//export CBDelegateCentralManagerDidDisconnectPeripheral +func CBDelegateCentralManagerDidDisconnectPeripheral(o unsafe.Pointer, central unsafe.Pointer, peripheral unsafe.Pointer, error unsafe.Pointer) { + CBDelegateMux.RLock() + cb := CBDelegateLookup[o].CentralManagerDidDisconnectPeripheral + CBDelegateMux.RUnlock() + if cb == nil { return } + a1 := &CBCentralManager{}; a1.ptr = central + a2 := &CBPeripheral{}; a2.ptr = peripheral + a3 := &NSError{}; a3.ptr = error + cb(a1, a2, a3) +} + //export CBDelegateCentralManagerDidDiscoverPeripheral func CBDelegateCentralManagerDidDiscoverPeripheral(o unsafe.Pointer, central unsafe.Pointer, peripheral unsafe.Pointer, advertisementData unsafe.Pointer, RSSI unsafe.Pointer) { CBDelegateMux.RLock() diff --git a/ns/main.go b/ns/main.go index 557c933..7499643 100644 --- a/ns/main.go +++ b/ns/main.go @@ -10,27025 +10,8 @@ package ns #import void* -selectorFromString(char *s) { - return NSSelectorFromString([NSString stringWithUTF8String:s]); -} - -void* -CBManager_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBManager instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -void* -CBManager_New() { - CBManager* ret; - @autoreleasepool { - ret = [CBManager new]; - } - return ret; - -} -void -CBManager_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBManager setVersion:aVersion]; - } -} -void* -CBManager_AllocWithZone(void* zone) { - return [CBManager allocWithZone:zone]; -} -void* -CBManager_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBManager description]; - } - return ret; - -} -void* -CBManager_Alloc() { - return [CBManager alloc]; -} -void* _Nonnull -CBManager_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBManager classForKeyedUnarchiver]; - } - return ret; - -} -void -CBManager_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBManager cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBManager_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBManager_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* -CBManager_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBManager superclass]; - } - return ret; - -} -void* _Nonnull -CBManager_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBManager classFallbacksForKeyedArchiver]; - } - return ret; - -} -void* _Nonnull -CBManager_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBManager keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -BOOL -CBManager_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBManager conformsToProtocol:protocol]; - } - return ret; - -} -void* -CBManager_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBManager debugDescription]; - } - return ret; - -} -BOOL -CBManager_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBManager instancesRespondToSelector:aSelector]; - } - return ret; - -} -BOOL -CBManager_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBManager accessInstanceVariablesDirectly]; - } - return ret; - -} -void* -CBManager_Class() { - Class ret; - @autoreleasepool { - ret = [CBManager class]; - } - return ret; - -} -BOOL -CBManager_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBManager resolveInstanceMethod:sel]; - } - return ret; - -} -BOOL -CBManager_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBManager resolveClassMethod:sel]; - } - return ret; - -} -BOOL -CBManager_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBManager isSubclassOfClass:aClass]; - } - return ret; - -} -void* -CBManager_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBManager copyWithZone:zone]; - } - return ret; - -} -NSInteger -CBManager_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBManager version]; - } - return ret; - -} -BOOL -CBManager_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBManager automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -NSUInteger -CBManager_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBManager hash]; - } - return ret; - -} -void -CBManager_Load() { - @autoreleasepool { - [CBManager load]; - } -} -void* -CBManager_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBManager mutableCopyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBManager_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBManager*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -BOOL -CBManager_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBManager_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBManager_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBManager_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nullable -CBManager_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o classForKeyedArchiver]; - } - return ret; - -} -void* _Nullable -CBManager_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nullable -CBManager_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o classForArchiver]; - } - return ret; - -} -void* _Nullable -CBManager_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isGreaterThan:object]; - } - return ret; - -} -BOOL -CBManager_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingIsEqualTo:object]; - } - return ret; - -} -BOOL -CBManager_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingBeginsWith:object]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingContains:object]; - } - return ret; - -} -BOOL -CBManager_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void -CBManager_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBManager*)o forwardInvocation:anInvocation]; - } -} -BOOL -CBManager_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingIsLessThan:object]; - } - return ret; - -} -void -CBManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBManager*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -BOOL -CBManager_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isLessThan:object]; - } - return ret; - -} -void -CBManager_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBManager_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nonnull -CBManager_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBManager_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nullable -CBManager_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingEndsWith:object]; - } - return ret; - -} -void -CBManager_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBManager_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nullable -CBManager_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBManager_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -BOOL -CBManager_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isLike:object]; - } - return ret; - -} -void -CBManager_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBManager*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBManager_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBManager*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -void -CBManager_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBManager*)o setValue:value forKey:key]; - } -} -void -CBManager_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBManager*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBManager_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBManager*)o setValue:value forUndefinedKey:key]; - } -} -BOOL -CBManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBManager_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o observationInfo]; - } - return ret; - -} -void* _Nullable -CBManager_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBManager*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void* _Nullable -CBManager_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBManager_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBManager_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBManager*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBManager*)o setScriptingProperties:scriptingProperties]; - } -} -void* -CBManager_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBManager*)o mutableCopy]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isNotEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o doesContain:object]; - } - return ret; - -} -void -CBManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBManager*)o doesNotRecognizeSelector:aSelector]; - } -} -void* _Nonnull -CBManager_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBManager_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBManager_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBManager_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -CBManager_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBManager*)o setObservationInfo:observationInfo]; - } -} -BOOL -CBManager_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBManager_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBManager_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBManager_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -CBManager_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBManager*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBManager_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBManager*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBManager_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBManager*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nullable -CBManager_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBManager_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o classForCoder]; - } - return ret; - -} -void* _Nullable -CBManager_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBManager_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBManager*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -CBManagerState -CBManager_inst_State(void* o) { - CBManagerState ret; - @autoreleasepool { - ret = [(CBManager*)o state]; - } - return ret; - -} -void* _Nonnull -CBManager_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBManager*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBManager*)o didChangeValueForKey:key]; - } -} -void -CBManager_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBManager_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBManager*)o dealloc]; - } -} -void -CBManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBManager_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBManager_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBManager_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nullable -CBManager_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -FourCharCode -CBManager_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBManager*)o classCode]; - } - return ret; - -} -void* -CBManager_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBManager*)o copy]; - } - return ret; - -} -void -CBManager_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBManager*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBManager_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBManager*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nullable -CBManager_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBManager_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBManager_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBManager_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBManager*)o setNilValueForKey:key]; - } -} -void* _Nullable -CBManager_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBManager*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBManager_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBManager*)o willChangeValueForKey:key]; - } -} -void -CBManager_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -NSInteger -CBAttribute_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBAttribute version]; - } - return ret; - -} -BOOL -CBAttribute_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -NSUInteger -CBAttribute_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBAttribute hash]; - } - return ret; - -} -void* -CBAttribute_Alloc() { - return [CBAttribute alloc]; -} -void* -CBAttribute_Class() { - Class ret; - @autoreleasepool { - ret = [CBAttribute class]; - } - return ret; - -} -BOOL -CBAttribute_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute conformsToProtocol:protocol]; - } - return ret; - -} -BOOL -CBAttribute_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute isSubclassOfClass:aClass]; - } - return ret; - -} -void* _Nonnull -CBAttribute_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBAttribute classForKeyedUnarchiver]; - } - return ret; - -} -BOOL -CBAttribute_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute accessInstanceVariablesDirectly]; - } - return ret; - -} -void* -CBAttribute_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBAttribute superclass]; - } - return ret; - -} -void* _Nonnull -CBAttribute_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBAttribute keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -void -CBAttribute_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBAttribute setVersion:aVersion]; - } -} -void -CBAttribute_Load() { - @autoreleasepool { - [CBAttribute load]; - } -} -void* -CBAttribute_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBAttribute mutableCopyWithZone:zone]; - } - return ret; - -} -BOOL -CBAttribute_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute resolveClassMethod:sel]; - } - return ret; - -} -void* -CBAttribute_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBAttribute debugDescription]; - } - return ret; - -} -void* -CBAttribute_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBAttribute copyWithZone:zone]; - } - return ret; - -} -void* -CBAttribute_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBAttribute description]; - } - return ret; - -} -void* -CBAttribute_New() { - CBAttribute* ret; - @autoreleasepool { - ret = [CBAttribute new]; - } - return ret; - -} -void* _Nonnull -CBAttribute_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBAttribute classFallbacksForKeyedArchiver]; - } - return ret; - -} -void* -CBAttribute_AllocWithZone(void* zone) { - return [CBAttribute allocWithZone:zone]; -} -BOOL -CBAttribute_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute resolveInstanceMethod:sel]; - } - return ret; - -} -void -CBAttribute_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBAttribute_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBAttribute_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* -CBAttribute_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBAttribute instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -BOOL -CBAttribute_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBAttribute instancesRespondToSelector:aSelector]; - } - return ret; - -} -void* -CBAttribute_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBAttribute*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBAttribute*)o didChangeValueForKey:key]; - } -} -void -CBAttribute_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBAttribute*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBAttribute_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBAttribute*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -BOOL -CBAttribute_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void -CBAttribute_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBAttribute*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBAttribute_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBAttribute*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -void* _Nullable -CBAttribute_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isLike:object]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void* _Nonnull -CBAttribute_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBAttribute*)o setScriptingProperties:scriptingProperties]; - } -} -void* _Nonnull -CBAttribute_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBAttribute*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBAttribute_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBAttribute*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nullable -CBAttribute_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBAttribute_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBAttribute_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBAttribute_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBAttribute_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nonnull -CBAttribute_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o observationInfo]; - } - return ret; - -} -void* -CBAttribute_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBAttribute*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -BOOL -CBAttribute_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isNotEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o classForCoder]; - } - return ret; - -} -void -CBAttribute_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBAttribute*)o setNilValueForKey:key]; - } -} -void* _Nullable -CBAttribute_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o classForKeyedArchiver]; - } - return ret; - -} -void -CBAttribute_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBAttribute*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBAttribute_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBAttribute*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nullable -CBAttribute_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isLessThan:object]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBAttribute*)o setObservationInfo:observationInfo]; - } -} -void* _Nonnull -CBAttribute_inst_UUID(void* o) { - CBUUID* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o UUID]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingBeginsWith:object]; - } - return ret; - -} -void -CBAttribute_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBAttribute*)o willChangeValueForKey:key]; - } -} -void -CBAttribute_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBAttribute*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBAttribute_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBAttribute*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* _Nonnull -CBAttribute_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBAttribute_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBAttribute_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBAttribute_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void -CBAttribute_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBAttribute*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBAttribute_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBAttribute*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -BOOL -CBAttribute_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* -CBAttribute_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableCopy]; - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBAttribute_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -BOOL -CBAttribute_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingEndsWith:object]; - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingIsLessThan:object]; - } - return ret; - -} -void -CBAttribute_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBAttribute*)o doesNotRecognizeSelector:aSelector]; - } -} -void* _Nullable -CBAttribute_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o classForArchiver]; - } - return ret; - -} -BOOL -CBAttribute_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o isGreaterThan:object]; - } - return ret; - -} -FourCharCode -CBAttribute_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBAttribute*)o classCode]; - } - return ret; - -} -BOOL -CBAttribute_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingContains:object]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBAttribute_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void -CBAttribute_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBAttribute*)o forwardInvocation:anInvocation]; - } -} -BOOL -CBAttribute_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o scriptingIsEqualTo:object]; - } - return ret; - -} -void -CBAttribute_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBAttribute*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBAttribute_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBAttribute*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBAttribute_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBAttribute*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nullable -CBAttribute_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBAttribute*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBAttribute*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void* _Nonnull -CBAttribute_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBAttribute*)o setValue:value forKey:key]; - } -} -void -CBAttribute_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBAttribute*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBAttribute_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBAttribute*)o setValue:value forUndefinedKey:key]; - } -} -void -CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBAttribute*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -void -CBAttribute_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBAttribute*)o dealloc]; - } -} -BOOL -CBAttribute_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBAttribute*)o doesContain:object]; - } - return ret; - -} -void -CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBAttribute*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBAttribute*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nonnull -CBAttribute_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBAttribute*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBAttribute_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBAttribute*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -void -CBAttribute_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBAttribute*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBAttribute_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBAttribute*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void* -CBAttribute_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBAttribute*)o copy]; - } - return ret; - -} -void* -CBUUID_Alloc() { - return [CBUUID alloc]; -} -void -CBUUID_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBUUID cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBUUID_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -NSUInteger -CBUUID_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBUUID hash]; - } - return ret; - -} -void* -CBUUID_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBUUID mutableCopyWithZone:zone]; - } - return ret; - -} -void* -CBUUID_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBUUID superclass]; - } - return ret; - -} -void* _Nonnull -CBUUID_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBUUID classFallbacksForKeyedArchiver]; - } - return ret; - -} -void* _Nonnull -CBUUID_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBUUID keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -BOOL -CBUUID_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID resolveInstanceMethod:sel]; - } - return ret; - -} -BOOL -CBUUID_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID conformsToProtocol:protocol]; - } - return ret; - -} -void* -CBUUID_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBUUID debugDescription]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -CBUUID_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBUUID copyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -CBUUID_UUIDWithNSUUID(void* theUUID) { - CBUUID* _Nonnull ret; - @autoreleasepool { - ret = [CBUUID UUIDWithNSUUID:theUUID]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -NSInteger -CBUUID_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBUUID version]; - } - return ret; - -} -BOOL -CBUUID_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBUUID accessInstanceVariablesDirectly]; - } - return ret; - -} -void* -CBUUID_AllocWithZone(void* zone) { - return [CBUUID allocWithZone:zone]; -} -void* -CBUUID_Class() { - Class ret; - @autoreleasepool { - ret = [CBUUID class]; - } - return ret; - -} -BOOL -CBUUID_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID resolveClassMethod:sel]; - } - return ret; - -} -BOOL -CBUUID_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID instancesRespondToSelector:aSelector]; - } - return ret; - -} -void* _Nonnull -CBUUID_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBUUID classForKeyedUnarchiver]; - } - return ret; - -} -void -CBUUID_Load() { - @autoreleasepool { - [CBUUID load]; - } -} -void* _Nonnull -CBUUID_UUIDWithString(void* theString) { - CBUUID* _Nonnull ret; - @autoreleasepool { - ret = [CBUUID UUIDWithString:theString]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_UUIDWithData(void* theData) { - CBUUID* _Nonnull ret; - @autoreleasepool { - ret = [CBUUID UUIDWithData:theData]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -CBUUID_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBUUID instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -BOOL -CBUUID_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* -CBUUID_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBUUID description]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -CBUUID_New() { - CBUUID* ret; - @autoreleasepool { - ret = [CBUUID new]; - } - return ret; - -} -void -CBUUID_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBUUID setVersion:aVersion]; - } -} -BOOL -CBUUID_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBUUID isSubclassOfClass:aClass]; - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingEndsWith:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o classForCoder]; - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -BOOL -CBUUID_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBUUID_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBUUID_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBUUID_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nullable -CBUUID_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o observationInfo]; - } - return ret; - -} -void -CBUUID_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBUUID*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void -CBUUID_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBUUID_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBUUID_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBUUID_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBUUID_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -BOOL -CBUUID_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingIsLessThan:object]; - } - return ret; - -} -void* -CBUUID_inst_Init(void* o) { - CBUUID* ret; - @autoreleasepool { - ret = [(CBUUID*)o init]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingContains:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -CBUUID_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBUUID*)o setNilValueForKey:key]; - } -} -void* _Nullable -CBUUID_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBUUID*)o dealloc]; - } -} -void* _Nullable -CBUUID_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_CopyWithZone(void* o, void* zone) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o copyWithZone:zone]; - } - return ret; - -} -void -CBUUID_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBUUID*)o forwardInvocation:anInvocation]; - } -} -void* _Nonnull -CBUUID_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -FourCharCode -CBUUID_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBUUID*)o classCode]; - } - return ret; - -} -BOOL -CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -BOOL -CBUUID_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isNotEqualTo:object]; - } - return ret; - -} -void -CBUUID_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBUUID*)o willChangeValueForKey:key]; - } -} -void -CBUUID_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* -CBUUID_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBUUID*)o copy]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_Data(void* o) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o data]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBUUID*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBUUID_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBUUID*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBUUID_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBUUID*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nullable -CBUUID_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBUUID*)o setScriptingProperties:scriptingProperties]; - } -} -void* _Nullable -CBUUID_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBUUID*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBUUID_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBUUID*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -void -CBUUID_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBUUID_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nullable -CBUUID_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBUUID_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -BOOL -CBUUID_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isGreaterThan:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBUUID*)o doesNotRecognizeSelector:aSelector]; - } -} -BOOL -CBUUID_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingIsEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBUUID*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -void* _Nullable -CBUUID_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_UUIDString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o UUIDString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBUUID_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBUUID_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBUUID_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void* _Nullable -CBUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBUUID_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void -CBUUID_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBUUID*)o setObservationInfo:observationInfo]; - } -} -void* -CBUUID_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBUUID*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBUUID_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBUUID*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -BOOL -CBUUID_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isLessThan:object]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBUUID*)o didChangeValueForKey:key]; - } -} -void -CBUUID_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBUUID_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBUUID*)o setValue:value forKey:key]; - } -} -void -CBUUID_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBUUID*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBUUID_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBUUID*)o setValue:value forUndefinedKey:key]; - } -} -void* -CBUUID_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBUUID*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBUUID_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nullable -CBUUID_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o classForArchiver]; - } - return ret; - -} -void* -CBUUID_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableCopy]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isLike:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBUUID_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o classForKeyedArchiver]; - } - return ret; - -} -BOOL -CBUUID_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o doesContain:object]; - } - return ret; - -} -BOOL -CBUUID_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o isEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingBeginsWith:object]; - } - return ret; - -} -void* _Nonnull -CBUUID_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBUUID*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBUUID_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBUUID*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBUUID_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBUUID*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -BOOL -NSString_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [NSString instancesRespondToSelector:aSelector]; - } - return ret; - -} -void* _Nullable -NSString_ObjectWithItemProviderDataTypeIdentifier(void* data, void* typeIdentifier, void** outError) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString objectWithItemProviderData:data typeIdentifier:typeIdentifier error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_ObjectWithItemProviderDataTypeIdentifierError(void* data, void* typeIdentifier, void** outError) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString objectWithItemProviderData:data typeIdentifier:typeIdentifier error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSString_WritableTypeIdentifiersForItemProvider() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSString writableTypeIdentifiersForItemProvider]; - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfURLEncoding(void* url, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfURLUsedEncoding(void* url, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfURLEncodingError(void* url, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfURLUsedEncodingError(void* url, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -const void* _Nonnull -NSString_AvailableStringEncodings() { - const NSStringEncoding* _Nonnull ret; - @autoreleasepool { - ret = [NSString availableStringEncodings]; - } - return ret; - -} -NSStringEncoding -NSString_StringEncodingForDataEncodingOptions(void* data, void* opts, void** string, void* usedLossyConversion) { - NSStringEncoding ret; - @autoreleasepool { - ret = [NSString stringEncodingForData:data encodingOptions:opts convertedString:(NSString* _Nullable* _Nullable)string usedLossyConversion:usedLossyConversion]; - for(int i=0;i<1;i++) { - if(string[i] == 0) { break; } - [(id)string[i] retain]; - } - - } - return ret; - -} -NSStringEncoding -NSString_StringEncodingForDataEncodingOptionsConvertedString(void* data, void* opts, void** string, void* usedLossyConversion) { - NSStringEncoding ret; - @autoreleasepool { - ret = [NSString stringEncodingForData:data encodingOptions:opts convertedString:(NSString* _Nullable* _Nullable)string usedLossyConversion:usedLossyConversion]; - for(int i=0;i<1;i++) { - if(string[i] == 0) { break; } - [(id)string[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [NSString resolveClassMethod:sel]; - } - return ret; - -} -void* -NSString_Class() { - Class ret; - @autoreleasepool { - ret = [NSString class]; - } - return ret; - -} -BOOL -NSString_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [NSString resolveInstanceMethod:sel]; - } - return ret; - -} -void -NSString_Load() { - @autoreleasepool { - [NSString load]; - } -} -NSItemProviderRepresentationVisibility -NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* typeIdentifier) { - NSItemProviderRepresentationVisibility ret; - @autoreleasepool { - ret = [NSString itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier]; - } - return ret; - -} -void* _Nonnull -NSString_String() { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString string]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_StringWithString(void* string) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString stringWithString:string]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSString_Superclass() { - Class ret; - @autoreleasepool { - ret = [NSString superclass]; - } - return ret; - -} -void* _Nonnull -NSString_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [NSString keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -void* _Nullable -NSString_StringWithCStringEncoding(void* cString, NSStringEncoding enc) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithCString:cString encoding:enc]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -NSInteger -NSString_Version() { - NSInteger ret; - @autoreleasepool { - ret = [NSString version]; - } - return ret; - -} -void* -NSString_New() { - NSString* ret; - @autoreleasepool { - ret = [NSString new]; - } - return ret; - -} -BOOL -NSString_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [NSString accessInstanceVariablesDirectly]; - } - return ret; - -} -void* -NSString_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSString copyWithZone:zone]; - } - return ret; - -} -void* -NSString_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [NSString debugDescription]; - } - return ret; - -} -void* _Nullable -NSString_StringWithUTF8String(void* nullTerminatedCString) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithUTF8String:nullTerminatedCString]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSString_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [NSString instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -void* -NSString_AllocWithZone(void* zone) { - return [NSString allocWithZone:zone]; -} -BOOL -NSString_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [NSString conformsToProtocol:protocol]; - } - return ret; - -} -void* _Nonnull -NSString_ReadableTypeIdentifiersForItemProvider() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSString readableTypeIdentifiersForItemProvider]; - } - return ret; - -} -BOOL -NSString_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [NSString automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* -NSString_Description() { - NSString* ret; - @autoreleasepool { - ret = [NSString description]; - } - return ret; - -} -void* _Nonnull -NSString_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [NSString classForKeyedUnarchiver]; - } - return ret; - -} -void -NSString_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [NSString setVersion:aVersion]; - } -} -NSUInteger -NSString_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [NSString hash]; - } - return ret; - -} -void* -NSString_Alloc() { - return [NSString alloc]; -} -void -NSString_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [NSString cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -NSString_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSString cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -NSString_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSString cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* _Nonnull -NSString_LocalizedNameOfStringEncoding(NSStringEncoding encoding) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString localizedNameOfStringEncoding:encoding]; - } - return ret; - -} -void* _Nonnull -NSString_StringWithFormat(void* format, void* object) { - NSObject** arr = object; - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString stringWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_StringWithCharactersLength(void* characters, NSUInteger length) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString stringWithCharacters:characters length:length]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_PathWithComponents(void* components) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString pathWithComponents:components]; - } - return ret; - -} -BOOL -NSString_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [NSString isSubclassOfClass:aClass]; - } - return ret; - -} -void* -NSString_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSString mutableCopyWithZone:zone]; - } - return ret; - -} -BOOL -NSString_SupportsSecureCoding() { - BOOL ret; - @autoreleasepool { - ret = [NSString supportsSecureCoding]; - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfFileEncoding(void* path, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfFileUsedEncoding(void* path, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfFileEncodingError(void* path, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_StringWithContentsOfFileUsedEncodingError(void* path, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [NSString stringWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSString_LocalizedStringWithFormat(void* format, void* object) { - NSObject** arr = object; - NSString* _Nonnull ret; - @autoreleasepool { - ret = [NSString localizedStringWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; - } - return ret; - -} -NSStringEncoding -NSString_DefaultCStringEncoding() { - NSStringEncoding ret; - @autoreleasepool { - ret = [NSString defaultCStringEncoding]; - } - return ret; - -} -void* _Nonnull -NSString_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSString classFallbacksForKeyedArchiver]; - } - return ret; - -} -BOOL -NSString_inst_GetBytesMaxLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover]; - } - return ret; - -} -BOOL -NSString_inst_GetBytesMaxLengthUsedLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover]; - } - return ret; - -} -NSStringEncoding -NSString_inst_SmallestEncoding(void* o) { - NSStringEncoding ret; - @autoreleasepool { - ret = [(NSString*)o smallestEncoding]; - } - return ret; - -} -BOOL -NSString_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -BOOL -NSString_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o writeToFile:path atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_inst_WriteToFileAtomicallyEncoding(void* o, void* path, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o writeToFile:path atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithCStringEncoding(void* o, void* nullTerminatedCString, NSStringEncoding encoding) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithCString:nullTerminatedCString encoding:encoding]; - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByTrimmingCharactersInSet(void* o, void* set) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByTrimmingCharactersInSet:set]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByFoldingWithOptionsLocale(void* o, NSStringCompareOptions options, void* locale) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByFoldingWithOptions:options locale:locale]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(NSString*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -void* _Nonnull -NSString_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o observationInfo]; - } - return ret; - -} -const void* _Nonnull -NSString_inst_FileSystemRepresentation(void* o) { - const char* _Nonnull ret; - @autoreleasepool { - ret = strdup([(NSString*)o fileSystemRepresentation]); - } - return ret; - -} -void* _Nonnull -NSString_inst_LowercaseString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o lowercaseString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isLike:object]; - } - return ret; - -} -void* _Nonnull -NSString_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfURLEncoding(void* o, void* url, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfURLUsedEncoding(void* o, void* url, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfURLEncodingError(void* o, void* url, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfURLUsedEncodingError(void* o, void* url, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSString_inst_Init(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o init]; - } - return ret; - -} -void* _Nonnull -NSString_inst_VariantFittingPresentationWidth(void* o, NSInteger width) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o variantFittingPresentationWidth:width]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -const void* _Nullable -NSString_inst_CStringUsingEncoding(void* o, NSStringEncoding encoding) { - const char* _Nullable ret; - @autoreleasepool { - ret = strdup([(NSString*)o cStringUsingEncoding:encoding]); - } - return ret; - -} -void* _Nonnull -NSString_inst_ComponentsSeparatedByCharactersInSet(void* o, void* separator) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o componentsSeparatedByCharactersInSet:separator]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(NSString*)o setObservationInfo:observationInfo]; - } -} -void* _Nonnull -NSString_inst_StringByPaddingToLengthWithString(void* o, NSUInteger newLength, void* padString, NSUInteger padIndex) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByPaddingToLength:newLength withString:padString startingAtIndex:padIndex]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByPaddingToLengthWithStringStartingAtIndex(void* o, NSUInteger newLength, void* padString, NSUInteger padIndex) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByPaddingToLength:newLength withString:padString startingAtIndex:padIndex]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_GetCharacters(void* o, void* buffer) { - @autoreleasepool { - [(NSString*)o getCharacters:buffer]; - } -} -void -NSString_inst_GetCharactersRange(void* o, void* buffer, NSRange range) { - @autoreleasepool { - [(NSString*)o getCharacters:buffer range:range]; - } -} -BOOL -NSString_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isGreaterThan:object]; - } - return ret; - -} -void* _Nullable -NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(void* o, void* allowedCharacters) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o stringByAddingPercentEncodingWithAllowedCharacters:allowedCharacters]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSUInteger -NSString_inst_MaximumLengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o maximumLengthOfBytesUsingEncoding:enc]; - } - return ret; - -} -BOOL -NSString_inst_IsAbsolutePath(void* o) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isAbsolutePath]; - } - return ret; - -} -void* _Nonnull -NSString_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingContains:object]; - } - return ret; - -} -BOOL -NSString_inst_HasSuffix(void* o, void* str) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o hasSuffix:str]; - } - return ret; - -} -void -NSString_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nonnull -NSString_inst_StringByDeletingLastPathComponent(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByDeletingLastPathComponent]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSUInteger -NSString_inst_Length(void* o) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o length]; - } - return ret; - -} -NSRange -NSString_inst_ParagraphRangeForRange(void* o, NSRange range) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o paragraphRangeForRange:range]; - } - return ret; - -} -void* _Nonnull -NSString_inst_DecomposedStringWithCanonicalMapping(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o decomposedStringWithCanonicalMapping]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByResolvingSymlinksInPath(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByResolvingSymlinksInPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfCharacterFromSet(void* o, void* searchSet) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfCharacterFromSet:searchSet]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfCharacterFromSetOptions(void* o, void* searchSet, NSStringCompareOptions mask) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfCharacterFromSetOptionsRange(void* o, void* searchSet, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask range:rangeOfReceiverToSearch]; - } - return ret; - -} -const void* _Nullable -NSString_inst_UTF8String(void* o) { - const char* _Nullable ret; - @autoreleasepool { - ret = strdup([(NSString*)o UTF8String]); - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithUTF8String(void* o, void* nullTerminatedCString) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithUTF8String:nullTerminatedCString]; - } - return ret; - -} -void -NSString_inst_GetParagraphStartEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) { - @autoreleasepool { - [(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range]; - } -} -void -NSString_inst_GetParagraphStartEndContentsEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) { - @autoreleasepool { - [(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range]; - } -} -void -NSString_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(NSString*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -NSString_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(NSString*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nonnull -NSString_inst_StringByStandardizingPath(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByStandardizingPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_LocalizedStandardContainsString(void* o, void* str) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o localizedStandardContainsString:str]; - } - return ret; - -} -void* _Nullable -NSString_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -double -NSString_inst_DoubleValue(void* o) { - double ret; - @autoreleasepool { - ret = [(NSString*)o doubleValue]; - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByAppendingString(void* o, void* aString) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByAppendingString:aString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -NSString_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSString*)o willChangeValueForKey:key]; - } -} -void -NSString_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* _Nonnull -NSString_inst_ComponentsSeparatedByString(void* o, void* separator) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o componentsSeparatedByString:separator]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nullable -NSString_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithBytesNoCopyLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer]; - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithBytesNoCopyLengthEncoding(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer]; - } - return ret; - -} -void* _Nullable -NSString_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o classForArchiver]; - } - return ret; - -} -void* -NSString_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(NSString*)o mutableCopy]; - } - return ret; - -} -void* _Nonnull -NSString_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSString_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(NSString*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByExpandingTildeInPath(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByExpandingTildeInPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(NSString*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -BOOL -NSString_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o doesContain:object]; - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithBytesLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding]; - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithBytesLengthEncoding(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding]; - } - return ret; - -} -void* _Nullable -NSString_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(NSString*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -BOOL -NSString_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingEndsWith:object]; - } - return ret; - -} -BOOL -NSString_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingIsLessThan:object]; - } - return ret; - -} -void* -NSString_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(NSString*)o copy]; - } - return ret; - -} -void* _Nonnull -NSString_inst_SubstringWithRange(void* o, NSRange range) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o substringWithRange:range]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_InitWithFormat(void* o, void* format, void* object) { - NSObject** arr = object; - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; - } - return ret; - -} -void* _Nonnull -NSString_inst_InitWithFormatLocale(void* o, void* format, void* locale, void* object) { - NSObject** arr = object; - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithFormat:format locale:locale , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; - } - return ret; - -} -BOOL -NSString_inst_WriteToURLAtomically(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_inst_WriteToURLAtomicallyEncoding(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSString_inst_PrecomposedStringWithCompatibilityMapping(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o precomposedStringWithCompatibilityMapping]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_GetCStringMaxLength(void* o, void* buffer, NSUInteger maxBufferCount, NSStringEncoding encoding) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o getCString:buffer maxLength:maxBufferCount encoding:encoding]; - } - return ret; - -} -BOOL -NSString_inst_GetCStringMaxLengthEncoding(void* o, void* buffer, NSUInteger maxBufferCount, NSStringEncoding encoding) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o getCString:buffer maxLength:maxBufferCount encoding:encoding]; - } - return ret; - -} -void* _Nullable -NSString_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSString*)o didChangeValueForKey:key]; - } -} -void -NSString_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSString*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -NSString_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSString*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* _Nonnull -NSString_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_MutableCopyWithZone(void* o, void* zone) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableCopyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -NSString_inst_UppercaseStringWithLocale(void* o, void* locale) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o uppercaseStringWithLocale:locale]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isNotEqualTo:object]; - } - return ret; - -} -void* _Nonnull -NSString_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringsByAppendingPaths(void* o, void* paths) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringsByAppendingPaths:paths]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_PropertyList(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o propertyList]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSString*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -NSString_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSString*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -NSComparisonResult -NSString_inst_LocalizedStandardCompare(void* o, void* string) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o localizedStandardCompare:string]; - } - return ret; - -} -void -NSString_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(NSString*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -NSString_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(NSString*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void* _Nullable -NSString_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsEqualToString(void* o, void* aString) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isEqualToString:aString]; - } - return ret; - -} -void* _Nonnull -NSString_inst_InitWithCharactersNoCopyLength(void* o, void* characters, NSUInteger length, BOOL freeBuffer) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithCharactersNoCopy:characters length:length freeWhenDone:freeBuffer]; - } - return ret; - -} -void* _Nonnull -NSString_inst_InitWithCharactersNoCopyLengthFreeWhenDone(void* o, void* characters, NSUInteger length, BOOL freeBuffer) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithCharactersNoCopy:characters length:length freeWhenDone:freeBuffer]; - } - return ret; - -} -float -NSString_inst_FloatValue(void* o) { - float ret; - @autoreleasepool { - ret = [(NSString*)o floatValue]; - } - return ret; - -} -NSUInteger -NSString_inst_Hash(void* o) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o hash]; - } - return ret; - -} -void* _Nonnull -NSString_inst_PathComponents(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o pathComponents]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSString*)o setNilValueForKey:key]; - } -} -void -NSString_inst_Dealloc(void* o) { - @autoreleasepool { - [(NSString*)o dealloc]; - } -} -void -NSString_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(NSString*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -NSString_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(NSString*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -NSComparisonResult -NSString_inst_CaseInsensitiveCompare(void* o, void* string) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o caseInsensitiveCompare:string]; - } - return ret; - -} -BOOL -NSString_inst_CanBeConvertedToEncoding(void* o, NSStringEncoding encoding) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o canBeConvertedToEncoding:encoding]; - } - return ret; - -} -void* _Nonnull -NSString_inst_CapitalizedString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o capitalizedString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSStringEncoding -NSString_inst_FastestEncoding(void* o) { - NSStringEncoding ret; - @autoreleasepool { - ret = [(NSString*)o fastestEncoding]; - } - return ret; - -} -void* _Nullable -NSString_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingIsEqualTo:object]; - } - return ret; - -} -NSItemProviderRepresentationVisibility -NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* o, void* typeIdentifier) { - NSItemProviderRepresentationVisibility ret; - @autoreleasepool { - ret = [(NSString*)o itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier]; - } - return ret; - -} -void* _Nonnull -NSString_inst_PrecomposedStringWithCanonicalMapping(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o precomposedStringWithCanonicalMapping]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByAppendingPathComponent(void* o, void* str) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByAppendingPathComponent:str]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_StringByApplyingTransformReverse(void* o, void* transform, BOOL reverse) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o stringByApplyingTransform:transform reverse:reverse]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(NSString*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -NSString_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(NSString*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -BOOL -NSString_inst_GetFileSystemRepresentationMaxLength(void* o, void* cname, NSUInteger max) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o getFileSystemRepresentation:cname maxLength:max]; - } - return ret; - -} -void -NSString_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(NSString*)o forwardInvocation:anInvocation]; - } -} -void* _Nonnull -NSString_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o classForCoder]; - } - return ret; - -} -void* _Nonnull -NSString_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -FourCharCode -NSString_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(NSString*)o classCode]; - } - return ret; - -} -BOOL -NSString_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void -NSString_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSString*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -NSString_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSString*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nullable -NSString_inst_DataUsingEncoding(void* o, NSStringEncoding encoding) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o dataUsingEncoding:encoding]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_DataUsingEncodingAllowLossyConversion(void* o, NSStringEncoding encoding, BOOL lossy) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o dataUsingEncoding:encoding allowLossyConversion:lossy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSComparisonResult -NSString_inst_LocalizedCompare(void* o, void* string) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o localizedCompare:string]; - } - return ret; - -} -int -NSString_inst_IntValue(void* o) { - int ret; - @autoreleasepool { - ret = [(NSString*)o intValue]; - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithCoder(void* o, void* aDecoder) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithCoder:aDecoder]; - } - return ret; - -} -void -NSString_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(NSString*)o setScriptingProperties:scriptingProperties]; - } -} -BOOL -NSString_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void* _Nonnull -NSString_inst_CopyWithZone(void* o, void* zone) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o copyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByAbbreviatingWithTildeInPath(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByAbbreviatingWithTildeInPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_DecomposedStringWithCompatibilityMapping(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o decomposedStringWithCompatibilityMapping]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSInteger -NSString_inst_IntegerValue(void* o) { - NSInteger ret; - @autoreleasepool { - ret = [(NSString*)o integerValue]; - } - return ret; - -} -void* _Nullable -NSString_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(NSString*)o doesNotRecognizeSelector:aSelector]; - } -} -void* _Nonnull -NSString_inst_LinguisticTagsInRangeScheme(void* o, NSRange range, void* scheme, NSLinguisticTaggerOptions options, void* orthography, void** tokenRanges) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o linguisticTagsInRange:range scheme:scheme options:options orthography:orthography tokenRanges:(NSArray * _Nullable* _Nullable)tokenRanges]; - if (ret != nil && ret != o) { [ret retain]; } - for(int i=0;i<1;i++) { - if(tokenRanges[i] == 0) { break; } - [(id)tokenRanges[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSString_inst_LinguisticTagsInRangeSchemeOptions(void* o, NSRange range, void* scheme, NSLinguisticTaggerOptions options, void* orthography, void** tokenRanges) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o linguisticTagsInRange:range scheme:scheme options:options orthography:orthography tokenRanges:(NSArray * _Nullable* _Nullable)tokenRanges]; - if (ret != nil && ret != o) { [ret retain]; } - for(int i=0;i<1;i++) { - if(tokenRanges[i] == 0) { break; } - [(id)tokenRanges[i] retain]; - } - - } - return ret; - -} -NSRange -NSString_inst_RangeOfComposedCharacterSequenceAtIndex(void* o, NSUInteger index) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfComposedCharacterSequenceAtIndex:index]; - } - return ret; - -} -void* _Nonnull -NSString_inst_LowercaseStringWithLocale(void* o, void* locale) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o lowercaseStringWithLocale:locale]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_LocalizedCapitalizedString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o localizedCapitalizedString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByDeletingPathExtension(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByDeletingPathExtension]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_HasPrefix(void* o, void* str) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o hasPrefix:str]; - } - return ret; - -} -void* _Nullable -NSString_inst_PropertyListFromStringsFileFormat(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o propertyListFromStringsFileFormat]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_GetLineStartEnd(void* o, void* startPtr, void* lineEndPtr, void* contentsEndPtr, NSRange range) { - @autoreleasepool { - [(NSString*)o getLineStart:startPtr end:lineEndPtr contentsEnd:contentsEndPtr forRange:range]; - } -} -void -NSString_inst_GetLineStartEndContentsEnd(void* o, void* startPtr, void* lineEndPtr, void* contentsEndPtr, NSRange range) { - @autoreleasepool { - [(NSString*)o getLineStart:startPtr end:lineEndPtr contentsEnd:contentsEndPtr forRange:range]; - } -} -void* _Nonnull -NSString_inst_Description(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o description]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_LocalizedUppercaseString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o localizedUppercaseString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByReplacingOccurrencesOfStringWithString(void* o, void* target, void* replacement) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_StringByAppendingPathExtension(void* o, void* str) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o stringByAppendingPathExtension:str]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -NSString_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nonnull -NSString_inst_SubstringToIndex(void* o, NSUInteger to) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o substringToIndex:to]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isLessThan:object]; - } - return ret; - -} -BOOL -NSString_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSString_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSString_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -NSString_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -NSString_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -NSString_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -NSString_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nonnull -NSString_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_LocalizedLowercaseString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o localizedLowercaseString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSRange -NSString_inst_LocalizedStandardRangeOfString(void* o, void* str) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o localizedStandardRangeOfString:str]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfComposedCharacterSequencesForRange(void* o, NSRange range) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfComposedCharacterSequencesForRange:range]; - } - return ret; - -} -void* _Nonnull -NSString_inst_CapitalizedStringWithLocale(void* o, void* locale) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o capitalizedStringWithLocale:locale]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSComparisonResult -NSString_inst_Compare(void* o, void* string) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o compare:string]; - } - return ret; - -} -NSComparisonResult -NSString_inst_CompareOptions(void* o, void* string, NSStringCompareOptions mask) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o compare:string options:mask]; - } - return ret; - -} -NSComparisonResult -NSString_inst_CompareOptionsRange(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare]; - } - return ret; - -} -NSComparisonResult -NSString_inst_CompareOptionsRangeLocale(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare, void* locale) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare locale:locale]; - } - return ret; - -} -BOOL -NSString_inst_LocalizedCaseInsensitiveContainsString(void* o, void* str) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o localizedCaseInsensitiveContainsString:str]; - } - return ret; - -} -void* _Nullable -NSString_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o classForKeyedArchiver]; - } - return ret; - -} -void* _Nullable -NSString_inst_StringByRemovingPercentEncoding(void* o) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o stringByRemovingPercentEncoding]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_BoolValue(void* o) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o boolValue]; - } - return ret; - -} -BOOL -NSString_inst_ContainsString(void* o, void* str) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o containsString:str]; - } - return ret; - -} -void -NSString_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSString*)o setValue:value forKey:key]; - } -} -void -NSString_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(NSString*)o setValue:value forKeyPath:keyPath]; - } -} -void -NSString_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSString*)o setValue:value forUndefinedKey:key]; - } -} -BOOL -NSString_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -NSUInteger -NSString_inst_LengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o lengthOfBytesUsingEncoding:enc]; - } - return ret; - -} -unichar -NSString_inst_CharacterAtIndex(void* o, NSUInteger index) { - unichar ret; - @autoreleasepool { - ret = [(NSString*)o characterAtIndex:index]; - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByAppendingFormat(void* o, void* format, void* object) { - NSObject** arr = object; - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByAppendingFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSString_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(NSString*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithDataEncoding(void* o, void* data, NSStringEncoding encoding) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithData:data encoding:encoding]; - } - return ret; - -} -BOOL -NSString_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o scriptingBeginsWith:object]; - } - return ret; - -} -void* _Nonnull -NSString_inst_WritableTypeIdentifiersForItemProvider(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o writableTypeIdentifiersForItemProvider]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSUInteger -NSString_inst_CompletePathIntoStringCaseSensitive(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray * _Nullable* _Nullable)outputArray filterTypes:filterTypes]; - for(int i=0;i<1;i++) { - if(outputName[i] == 0) { break; } - [(id)outputName[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outputArray[i] == 0) { break; } - [(id)outputArray[i] retain]; - } - - } - return ret; - -} -NSUInteger -NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray * _Nullable* _Nullable)outputArray filterTypes:filterTypes]; - for(int i=0;i<1;i++) { - if(outputName[i] == 0) { break; } - [(id)outputName[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outputArray[i] == 0) { break; } - [(id)outputArray[i] retain]; - } - - } - return ret; - -} -NSRange -NSString_inst_LineRangeForRange(void* o, NSRange range) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o lineRangeForRange:range]; - } - return ret; - -} -void* _Nonnull -NSString_inst_SubstringFromIndex(void* o, NSUInteger from) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o substringFromIndex:from]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_UppercaseString(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o uppercaseString]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_LastPathComponent(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o lastPathComponent]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSComparisonResult -NSString_inst_LocalizedCaseInsensitiveCompare(void* o, void* string) { - NSComparisonResult ret; - @autoreleasepool { - ret = [(NSString*)o localizedCaseInsensitiveCompare:string]; - } - return ret; - -} -void* _Nonnull -NSString_inst_PathExtension(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o pathExtension]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSString_inst_CommonPrefixWithStringOptions(void* o, void* str, NSStringCompareOptions mask) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o commonPrefixWithString:str options:mask]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSRange -NSString_inst_RangeOfString(void* o, void* searchString) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfString:searchString]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfStringOptions(void* o, void* searchString, NSStringCompareOptions mask) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfString:searchString options:mask]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfStringOptionsRange(void* o, void* searchString, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfString:searchString options:mask range:rangeOfReceiverToSearch]; - } - return ret; - -} -NSRange -NSString_inst_RangeOfStringOptionsRangeLocale(void* o, void* searchString, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch, void* locale) { - NSRange ret; - @autoreleasepool { - ret = [(NSString*)o rangeOfString:searchString options:mask range:rangeOfReceiverToSearch locale:locale]; - } - return ret; - -} -void -NSString_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSString*)o insertValue:value inPropertyWithKey:key]; - } -} -void -NSString_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -NSString_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nonnull -NSString_inst_InitWithCharactersLength(void* o, void* characters, NSUInteger length) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithCharacters:characters length:length]; - } - return ret; - -} -void* _Nonnull -NSString_inst_StringByReplacingCharactersInRangeWithString(void* o, NSRange range, void* replacement) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o stringByReplacingCharactersInRange:range withString:replacement]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfFileEncoding(void* o, void* path, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfFileUsedEncoding(void* o, void* path, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfFileEncodingError(void* o, void* path, NSStringEncoding enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSString_inst_InitWithContentsOfFileUsedEncodingError(void* o, void* path, void* enc, void** error) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -long long -NSString_inst_LongLongValue(void* o) { - long long ret; - @autoreleasepool { - ret = [(NSString*)o longLongValue]; - } - return ret; - -} -void* _Nonnull -NSString_inst_InitWithString(void* o, void* aString) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSString*)o initWithString:aString]; - } - return ret; - -} -void* _Nullable -NSString_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSString_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSString*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSString_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSString*)o isEqualTo:object]; - } - return ret; - -} -void -NSData_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [NSData setVersion:aVersion]; - } -} -void* _Nonnull -NSData_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [NSData classForKeyedUnarchiver]; - } - return ret; - -} -void* -NSData_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSData mutableCopyWithZone:zone]; - } - return ret; - -} -void -NSData_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [NSData cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -NSData_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSData cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -NSData_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSData cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* _Nonnull -NSData_Data() { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [NSData data]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSData classFallbacksForKeyedArchiver]; - } - return ret; - -} -BOOL -NSData_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [NSData isSubclassOfClass:aClass]; - } - return ret; - -} -void* -NSData_Alloc() { - return [NSData alloc]; -} -void* -NSData_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [NSData instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -void* -NSData_Class() { - Class ret; - @autoreleasepool { - ret = [NSData class]; - } - return ret; - -} -void* _Nonnull -NSData_DataWithData(void* data) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [NSData dataWithData:data]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSData_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSData copyWithZone:zone]; - } - return ret; - -} -NSInteger -NSData_Version() { - NSInteger ret; - @autoreleasepool { - ret = [NSData version]; - } - return ret; - -} -BOOL -NSData_SupportsSecureCoding() { - BOOL ret; - @autoreleasepool { - ret = [NSData supportsSecureCoding]; - } - return ret; - -} -BOOL -NSData_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [NSData accessInstanceVariablesDirectly]; - } - return ret; - -} -BOOL -NSData_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [NSData automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* _Nonnull -NSData_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [NSData keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -BOOL -NSData_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [NSData instancesRespondToSelector:aSelector]; - } - return ret; - -} -NSUInteger -NSData_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [NSData hash]; - } - return ret; - -} -void* _Nonnull -NSData_DataWithBytesLength(void* bytes, NSUInteger length) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [NSData dataWithBytes:bytes length:length]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_DataWithBytesNoCopyLength(void* bytes, NSUInteger length) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [NSData dataWithBytesNoCopy:bytes length:length]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_DataWithBytesNoCopyLengthFreeWhenDone(void* bytes, NSUInteger length, BOOL b) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:b]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -BOOL -NSData_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [NSData resolveInstanceMethod:sel]; - } - return ret; - -} -BOOL -NSData_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [NSData resolveClassMethod:sel]; - } - return ret; - -} -void* -NSData_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [NSData debugDescription]; - } - return ret; - -} -void* _Nullable -NSData_DataWithContentsOfFile(void* path) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfFile:path]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_DataWithContentsOfFileOptions(void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSData_DataWithContentsOfFileOptionsError(void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* -NSData_AllocWithZone(void* zone) { - return [NSData allocWithZone:zone]; -} -void* _Nullable -NSData_DataWithContentsOfURL(void* url) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfURL:url]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_DataWithContentsOfURLOptions(void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSData_DataWithContentsOfURLOptionsError(void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [NSData dataWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void -NSData_Load() { - @autoreleasepool { - [NSData load]; - } -} -BOOL -NSData_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [NSData conformsToProtocol:protocol]; - } - return ret; - -} -void* -NSData_Description() { - NSString* ret; - @autoreleasepool { - ret = [NSData description]; - } - return ret; - -} -void* -NSData_New() { - NSData* ret; - @autoreleasepool { - ret = [NSData new]; - } - return ret; - -} -void* -NSData_Superclass() { - Class ret; - @autoreleasepool { - ret = [NSData superclass]; - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithBase64EncodedDataOptions(void* o, void* base64Data, NSDataBase64DecodingOptions options) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithBase64EncodedData:base64Data options:options]; - } - return ret; - -} -BOOL -NSData_inst_WriteToURLAtomically(void* o, void* url, BOOL atomically) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToURL:url atomically:atomically]; - } - return ret; - -} -BOOL -NSData_inst_WriteToURLOptions(void* o, void* url, NSDataWritingOptions writeOptionsMask, void** errorPtr) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToURL:url options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_WriteToURLOptionsError(void* o, void* url, NSDataWritingOptions writeOptionsMask, void** errorPtr) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToURL:url options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingEndsWith:object]; - } - return ret; - -} -void -NSData_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -NSData_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -NSData_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -NSData_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -NSData_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void* -NSData_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(NSData*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfURL(void* o, void* url) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfURL:url]; - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfURLOptions(void* o, void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfURLOptionsError(void* o, void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -NSData_inst_InitWithBytesNoCopyLength(void* o, void* bytes, NSUInteger length) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o initWithBytesNoCopy:bytes length:length]; - } - return ret; - -} -void* _Nonnull -NSData_inst_InitWithBytesNoCopyLengthFreeWhenDone(void* o, void* bytes, NSUInteger length, BOOL b) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o initWithBytesNoCopy:bytes length:length freeWhenDone:b]; - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfFile(void* o, void* path) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfFile:path]; - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfFileOptions(void* o, void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithContentsOfFileOptionsError(void* o, void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isNotEqualTo:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_inst_Description(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o description]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -FourCharCode -NSData_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(NSData*)o classCode]; - } - return ret; - -} -void -NSData_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(NSData*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void -NSData_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(NSData*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -NSData_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(NSData*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nonnull -NSData_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSData_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingIsLessThan:object]; - } - return ret; - -} -BOOL -NSData_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -BOOL -NSData_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isLike:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(NSData*)o setObservationInfo:observationInfo]; - } -} -void* _Nonnull -NSData_inst_InitWithBytesLength(void* o, void* bytes, NSUInteger length) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o initWithBytes:bytes length:length]; - } - return ret; - -} -BOOL -NSData_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void -NSData_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(NSData*)o doesNotRecognizeSelector:aSelector]; - } -} -void -NSData_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSData*)o setValue:value forKey:key]; - } -} -void -NSData_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(NSData*)o setValue:value forKeyPath:keyPath]; - } -} -void -NSData_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSData*)o setValue:value forUndefinedKey:key]; - } -} -void -NSData_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(NSData*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -BOOL -NSData_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -BOOL -NSData_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingIsEqualTo:object]; - } - return ret; - -} -void -NSData_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(NSData*)o setScriptingProperties:scriptingProperties]; - } -} -NSUInteger -NSData_inst_Length(void* o) { - NSUInteger ret; - @autoreleasepool { - ret = [(NSData*)o length]; - } - return ret; - -} -void* _Nullable -NSData_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(NSData*)o forwardInvocation:anInvocation]; - } -} -void -NSData_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(NSData*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -NSData_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(NSData*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void* _Nonnull -NSData_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_GetBytesLength(void* o, void* buffer, NSUInteger length) { - @autoreleasepool { - [(NSData*)o getBytes:buffer length:length]; - } -} -void -NSData_inst_GetBytesRange(void* o, void* buffer, NSRange range) { - @autoreleasepool { - [(NSData*)o getBytes:buffer range:range]; - } -} -void* _Nonnull -NSData_inst_InitWithData(void* o, void* data) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o initWithData:data]; - } - return ret; - -} -BOOL -NSData_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isLessThan:object]; - } - return ret; - -} -void* _Nullable -NSData_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSData_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isGreaterThan:object]; - } - return ret; - -} -void -NSData_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(NSData*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -BOOL -NSData_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nullable -NSData_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o classForKeyedArchiver]; - } - return ret; - -} -void* _Nonnull -NSData_inst_SubdataWithRange(void* o, NSRange range) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o subdataWithRange:range]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSData_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(NSData*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSData*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -NSData_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSData*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nonnull -NSData_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o classForArchiver]; - } - return ret; - -} -void -NSData_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSData*)o willChangeValueForKey:key]; - } -} -void -NSData_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSData*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -NSData_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSData*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* _Nonnull -NSData_inst_CopyWithZone(void* o, void* zone) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o copyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -NSData_inst_MutableCopyWithZone(void* o, void* zone) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableCopyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -NSData_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(NSData*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -NSData_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(NSData*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nullable -NSData_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSData*)o setNilValueForKey:key]; - } -} -void -NSData_inst_Dealloc(void* o) { - @autoreleasepool { - [(NSData*)o dealloc]; - } -} -void* _Nonnull -NSData_inst_Base64EncodedStringWithOptions(void* o, NSDataBase64EncodingOptions options) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o base64EncodedStringWithOptions:options]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -NSData_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o observationInfo]; - } - return ret; - -} -void -NSData_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(NSData*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -NSData_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(NSData*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -BOOL -NSData_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o doesContain:object]; - } - return ret; - -} -void* _Nullable -NSData_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -NSData_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nonnull -NSData_inst_Base64EncodedDataWithOptions(void* o, NSDataBase64EncodingOptions options) { - NSData* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o base64EncodedDataWithOptions:options]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -NSData_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void -NSData_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSData*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -NSData_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(NSData*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nonnull -NSData_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSData_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(NSData*)o copy]; - } - return ret; - -} -BOOL -NSData_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingContains:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSData_inst_Init(void* o) { - NSData* ret; - @autoreleasepool { - ret = [(NSData*)o init]; - } - return ret; - -} -const void* _Nonnull -NSData_inst_Bytes(void* o) { - const void* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o bytes]; - } - return ret; - -} -BOOL -NSData_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -BOOL -NSData_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -NSData_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -NSData_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(NSData*)o mutableCopy]; - } - return ret; - -} -BOOL -NSData_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o scriptingBeginsWith:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSData_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToFile:path atomically:useAuxiliaryFile]; - } - return ret; - -} -BOOL -NSData_inst_WriteToFileOptions(void* o, void* path, NSDataWritingOptions writeOptionsMask, void** errorPtr) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToFile:path options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_WriteToFileOptionsError(void* o, void* path, NSDataWritingOptions writeOptionsMask, void** errorPtr) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o writeToFile:path options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr]; - for(int i=0;i<1;i++) { - if(errorPtr[i] == 0) { break; } - [(id)errorPtr[i] retain]; - } - - } - return ret; - -} -BOOL -NSData_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o classForCoder]; - } - return ret; - -} -void -NSData_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -BOOL -NSData_inst_IsEqualToData(void* o, void* other) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isEqualToData:other]; - } - return ret; - -} -void* _Nullable -NSData_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -NSData_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(NSData*)o insertValue:value inPropertyWithKey:key]; - } -} -void -NSData_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(NSData*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -NSData_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(NSData*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -NSData_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(NSData*)o didChangeValueForKey:key]; - } -} -void -NSData_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSData*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -NSData_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(NSData*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -BOOL -NSData_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o isEqualTo:object]; - } - return ret; - -} -void* _Nonnull -NSData_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSRange -NSData_inst_RangeOfDataOptions(void* o, void* dataToFind, NSDataSearchOptions mask, NSRange searchRange) { - NSRange ret; - @autoreleasepool { - ret = [(NSData*)o rangeOfData:dataToFind options:mask range:searchRange]; - } - return ret; - -} -NSRange -NSData_inst_RangeOfDataOptionsRange(void* o, void* dataToFind, NSDataSearchOptions mask, NSRange searchRange) { - NSRange ret; - @autoreleasepool { - ret = [(NSData*)o rangeOfData:dataToFind options:mask range:searchRange]; - } - return ret; - -} -void* _Nullable -NSData_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -NSData_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void* _Nonnull -NSData_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(NSData*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSData_inst_InitWithBase64EncodedStringOptions(void* o, void* base64String, NSDataBase64DecodingOptions options) { - NSData* _Nullable ret; - @autoreleasepool { - ret = [(NSData*)o initWithBase64EncodedString:base64String options:options]; - } - return ret; - -} -NSUInteger -CBCentralManager_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBCentralManager hash]; - } - return ret; - -} -void* -CBCentralManager_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBCentralManager mutableCopyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBCentralManager classForKeyedUnarchiver]; - } - return ret; - -} -void* -CBCentralManager_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBCentralManager superclass]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBCentralManager classFallbacksForKeyedArchiver]; - } - return ret; - -} -BOOL -CBCentralManager_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager accessInstanceVariablesDirectly]; - } - return ret; - -} -BOOL -CBCentralManager_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager resolveClassMethod:sel]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBCentralManager keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -BOOL -CBCentralManager_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager conformsToProtocol:protocol]; - } - return ret; - -} -BOOL -CBCentralManager_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager instancesRespondToSelector:aSelector]; - } - return ret; - -} -void* -CBCentralManager_Class() { - Class ret; - @autoreleasepool { - ret = [CBCentralManager class]; - } - return ret; - -} -NSInteger -CBCentralManager_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBCentralManager version]; - } - return ret; - -} -BOOL -CBCentralManager_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* -CBCentralManager_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBCentralManager instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -void -CBCentralManager_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBCentralManager setVersion:aVersion]; - } -} -void* -CBCentralManager_Alloc() { - return [CBCentralManager alloc]; -} -void -CBCentralManager_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBCentralManager_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBCentralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* -CBCentralManager_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBCentralManager debugDescription]; - } - return ret; - -} -void* -CBCentralManager_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBCentralManager copyWithZone:zone]; - } - return ret; - -} -void -CBCentralManager_Load() { - @autoreleasepool { - [CBCentralManager load]; - } -} -void* -CBCentralManager_New() { - CBCentralManager* ret; - @autoreleasepool { - ret = [CBCentralManager new]; - } - return ret; - -} -void* -CBCentralManager_AllocWithZone(void* zone) { - return [CBCentralManager allocWithZone:zone]; -} -void* -CBCentralManager_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBCentralManager description]; - } - return ret; - -} -BOOL -CBCentralManager_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager resolveInstanceMethod:sel]; - } - return ret; - -} -BOOL -CBCentralManager_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBCentralManager isSubclassOfClass:aClass]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingEndsWith:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentralManager*)o didChangeValueForKey:key]; - } -} -void -CBCentralManager_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBCentralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -BOOL -CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBCentralManager_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBCentralManager_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBCentralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentralManager*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -void* _Nonnull -CBCentralManager_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBCentralManager*)o doesNotRecognizeSelector:aSelector]; - } -} -FourCharCode -CBCentralManager_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBCentralManager*)o classCode]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingContains:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBCentralManager*)o setObservationInfo:observationInfo]; - } -} -BOOL -CBCentralManager_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isNotEqualTo:object]; - } - return ret; - -} -BOOL -CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -CBCentralManager_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentralManager*)o setNilValueForKey:key]; - } -} -void* _Nonnull -CBCentralManager_inst_Init(void* o) { - CBCentralManager* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o init]; - } - return ret; - -} -BOOL -CBCentralManager_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isLessThan:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBCentralManager_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableCopy]; - } - return ret; - -} -void -CBCentralManager_inst_CancelPeripheralConnection(void* o, void* peripheral) { - @autoreleasepool { - [(CBCentralManager*)o cancelPeripheralConnection:peripheral]; - } -} -void* _Nonnull -CBCentralManager_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentralManager*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBCentralManager_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentralManager*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBCentralManager_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentralManager*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nullable -CBCentralManager_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o classForArchiver]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o classForCoder]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o classForKeyedArchiver]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o observationInfo]; - } - return ret; - -} -void -CBCentralManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBCentralManager*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void* _Nullable -CBCentralManager_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_RetrieveConnectedPeripheralsWithServices(void* o, void* serviceUUIDs) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o retrieveConnectedPeripheralsWithServices:serviceUUIDs]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBCentralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBCentralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBCentralManager_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBCentralManager_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* _Nullable -CBCentralManager_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -BOOL -CBCentralManager_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isLike:object]; - } - return ret; - -} -BOOL -CBCentralManager_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o doesContain:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isGreaterThan:object]; - } - return ret; - -} -BOOL -CBCentralManager_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingIsEqualTo:object]; - } - return ret; - -} -BOOL -CBCentralManager_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingBeginsWith:object]; - } - return ret; - -} -void -CBCentralManager_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nullable -CBCentralManager_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentralManager*)o willChangeValueForKey:key]; - } -} -void -CBCentralManager_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBCentralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBCentralManager_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBCentralManager_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -BOOL -CBCentralManager_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsScanning(void* o) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isScanning]; - } - return ret; - -} -void -CBCentralManager_inst_ConnectPeripheral(void* o, void* peripheral, void* options) { - @autoreleasepool { - [(CBCentralManager*)o connectPeripheral:peripheral options:options]; - } -} -void -CBCentralManager_inst_StopScan(void* o) { - @autoreleasepool { - [(CBCentralManager*)o stopScan]; - } -} -void* _Nullable -CBCentralManager_inst_Delegate(void* o) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o delegate]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBCentralManager_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBCentralManager_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBCentralManager_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nullable -CBCentralManager_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBCentralManager*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBCentralManager_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBCentralManager*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -CBManagerState -CBCentralManager_inst_State(void* o) { - CBManagerState ret; - @autoreleasepool { - ret = [(CBCentralManager*)o state]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_InitWithDelegateQueue(void* o, void* delegate, void* queue) { - CBCentralManager* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o initWithDelegate:delegate queue:queue]; - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_InitWithDelegateQueueOptions(void* o, void* delegate, void* queue, void* options) { - CBCentralManager* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o initWithDelegate:delegate queue:queue options:options]; - } - return ret; - -} -void -CBCentralManager_inst_ScanForPeripheralsWithServices(void* o, void* serviceUUIDs, void* options) { - @autoreleasepool { - [(CBCentralManager*)o scanForPeripheralsWithServices:serviceUUIDs options:options]; - } -} -BOOL -CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void* -CBCentralManager_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentralManager*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentralManager_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void -CBCentralManager_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentralManager*)o setValue:value forKey:key]; - } -} -void -CBCentralManager_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBCentralManager*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBCentralManager_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentralManager*)o setValue:value forUndefinedKey:key]; - } -} -void -CBCentralManager_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBCentralManager*)o dealloc]; - } -} -void* _Nullable -CBCentralManager_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBCentralManager_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBCentralManager*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBCentralManager_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentralManager*)o copy]; - } - return ret; - -} -void -CBCentralManager_inst_SetDelegate(void* o, void* delegate) { - @autoreleasepool { - [(CBCentralManager*)o setDelegate:delegate]; - } -} -void* _Nonnull -CBCentralManager_inst_RetrievePeripheralsWithIdentifiers(void* o, void* identifiers) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o retrievePeripheralsWithIdentifiers:identifiers]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBCentralManager*)o forwardInvocation:anInvocation]; - } -} -BOOL -CBCentralManager_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o scriptingIsLessThan:object]; - } - return ret; - -} -void -CBCentralManager_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBCentralManager_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBCentralManager_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nullable -CBCentralManager_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentralManager_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentralManager*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -BOOL -CBCentralManager_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentralManager_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentralManager_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentralManager_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void -CBCentralManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBCentralManager*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -void* _Nullable -CBCentralManager_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentralManager_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentralManager*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentralManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBCentralManager*)o setScriptingProperties:scriptingProperties]; - } -} -BOOL -CBCentral_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBCentral accessInstanceVariablesDirectly]; - } - return ret; - -} -BOOL -CBCentral_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* -CBCentral_Alloc() { - return [CBCentral alloc]; -} -void -CBCentral_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBCentral cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBCentral_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBCentral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBCentral_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBCentral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* -CBCentral_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBCentral instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -NSInteger -CBCentral_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBCentral version]; - } - return ret; - -} -void* -CBCentral_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBCentral superclass]; - } - return ret; - -} -void* _Nonnull -CBCentral_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBCentral classFallbacksForKeyedArchiver]; - } - return ret; - -} -void* -CBCentral_AllocWithZone(void* zone) { - return [CBCentral allocWithZone:zone]; -} -void* -CBCentral_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBCentral copyWithZone:zone]; - } - return ret; - -} -void* -CBCentral_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBCentral mutableCopyWithZone:zone]; - } - return ret; - -} -void -CBCentral_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBCentral setVersion:aVersion]; - } -} -BOOL -CBCentral_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral resolveInstanceMethod:sel]; - } - return ret; - -} -BOOL -CBCentral_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral instancesRespondToSelector:aSelector]; - } - return ret; - -} -NSUInteger -CBCentral_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBCentral hash]; - } - return ret; - -} -void* _Nonnull -CBCentral_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBCentral classForKeyedUnarchiver]; - } - return ret; - -} -void -CBCentral_Load() { - @autoreleasepool { - [CBCentral load]; - } -} -void* -CBCentral_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBCentral description]; - } - return ret; - -} -void* -CBCentral_New() { - CBCentral* ret; - @autoreleasepool { - ret = [CBCentral new]; - } - return ret; - -} -void* _Nonnull -CBCentral_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBCentral keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -void* -CBCentral_Class() { - Class ret; - @autoreleasepool { - ret = [CBCentral class]; - } - return ret; - -} -BOOL -CBCentral_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral conformsToProtocol:protocol]; - } - return ret; - -} -BOOL -CBCentral_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral resolveClassMethod:sel]; - } - return ret; - -} -BOOL -CBCentral_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBCentral isSubclassOfClass:aClass]; - } - return ret; - -} -void* -CBCentral_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBCentral debugDescription]; - } - return ret; - -} -void* -CBCentral_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBCentral*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentral_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o classForCoder]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentral*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -void* _Nonnull -CBCentral_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBCentral_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBCentral_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -BOOL -CBCentral_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isNotEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBCentral*)o forwardInvocation:anInvocation]; - } -} -void* _Nullable -CBCentral_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentral*)o setValue:value forKey:key]; - } -} -void -CBCentral_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBCentral*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBCentral_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentral*)o setValue:value forUndefinedKey:key]; - } -} -void -CBCentral_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentral*)o willChangeValueForKey:key]; - } -} -void -CBCentral_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBCentral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -FourCharCode -CBCentral_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBCentral*)o classCode]; - } - return ret; - -} -BOOL -CBCentral_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* -CBCentral_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentral*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o classForArchiver]; - } - return ret; - -} -void -CBCentral_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBCentral*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -void -CBCentral_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBCentral*)o setObservationInfo:observationInfo]; - } -} -void -CBCentral_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBCentral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBCentral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBCentral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nullable -CBCentral_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -NSUInteger -CBCentral_inst_MaximumUpdateValueLength(void* o) { - NSUInteger ret; - @autoreleasepool { - ret = [(CBCentral*)o maximumUpdateValueLength]; - } - return ret; - -} -void -CBCentral_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBCentral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBCentral_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBCentral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -BOOL -CBCentral_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingIsLessThan:object]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isLike:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentral_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBCentral*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBCentral_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentral*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBCentral_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBCentral*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nonnull -CBCentral_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBCentral_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentral*)o copy]; - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingIsEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_Identifier(void* o) { - NSUUID* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o identifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBCentral_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBCentral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBCentral_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentral*)o didChangeValueForKey:key]; - } -} -void -CBCentral_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBCentral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBCentral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -BOOL -CBCentral_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingBeginsWith:object]; - } - return ret; - -} -void -CBCentral_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBCentral*)o doesNotRecognizeSelector:aSelector]; - } -} -BOOL -CBCentral_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isGreaterThan:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingContains:object]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o classForKeyedArchiver]; - } - return ret; - -} -BOOL -CBCentral_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o doesContain:object]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -BOOL -CBCentral_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o observationInfo]; - } - return ret; - -} -void -CBCentral_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBCentral*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBCentral_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBCentral*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -BOOL -CBCentral_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -BOOL -CBCentral_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingEndsWith:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isLessThan:object]; - } - return ret; - -} -void -CBCentral_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBCentral*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void -CBCentral_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBCentral*)o dealloc]; - } -} -void -CBCentral_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBCentral_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBCentral_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBCentral_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBCentral_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBCentral_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void* _Nonnull -CBCentral_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBCentral_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBCentral*)o setNilValueForKey:key]; - } -} -void* -CBCentral_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableCopy]; - } - return ret; - -} -void -CBCentral_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBCentral*)o setScriptingProperties:scriptingProperties]; - } -} -BOOL -CBCentral_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void -CBCentral_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBCentral*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBCentral_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBCentral*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void* _Nonnull -CBCentral_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBCentral_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentral_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentral_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBCentral_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBCentral_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBCentral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBCentral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nonnull -CBCentral_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBCentral*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBDescriptor_Superclass() { - Class ret; - @autoreleasepool { - ret = [CBDescriptor superclass]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [CBDescriptor keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -void* -CBDescriptor_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBDescriptor mutableCopyWithZone:zone]; - } - return ret; - -} -void* -CBDescriptor_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [CBDescriptor copyWithZone:zone]; - } - return ret; - -} -void* -CBDescriptor_New() { - CBDescriptor* ret; - @autoreleasepool { - ret = [CBDescriptor new]; - } - return ret; - -} -void -CBDescriptor_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -CBDescriptor_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -CBDescriptor_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -BOOL -CBDescriptor_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -BOOL -CBDescriptor_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor accessInstanceVariablesDirectly]; - } - return ret; - -} -void -CBDescriptor_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [CBDescriptor setVersion:aVersion]; - } -} -void* -CBDescriptor_Description() { - NSString* ret; - @autoreleasepool { - ret = [CBDescriptor description]; - } - return ret; - -} -BOOL -CBDescriptor_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor isSubclassOfClass:aClass]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [CBDescriptor classForKeyedUnarchiver]; - } - return ret; - -} -void -CBDescriptor_Load() { - @autoreleasepool { - [CBDescriptor load]; - } -} -BOOL -CBDescriptor_ResolveClassMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor resolveClassMethod:sel]; - } - return ret; - -} -NSUInteger -CBDescriptor_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [CBDescriptor hash]; - } - return ret; - -} -void* -CBDescriptor_Alloc() { - return [CBDescriptor alloc]; -} -void* -CBDescriptor_Class() { - Class ret; - @autoreleasepool { - ret = [CBDescriptor class]; - } - return ret; - -} -BOOL -CBDescriptor_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor conformsToProtocol:protocol]; - } - return ret; - -} -void* -CBDescriptor_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [CBDescriptor instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -BOOL -CBDescriptor_InstancesRespondToSelector(void* aSelector) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor instancesRespondToSelector:aSelector]; - } - return ret; - -} -BOOL -CBDescriptor_ResolveInstanceMethod(void* sel) { - BOOL ret; - @autoreleasepool { - ret = [CBDescriptor resolveInstanceMethod:sel]; - } - return ret; - -} -NSInteger -CBDescriptor_Version() { - NSInteger ret; - @autoreleasepool { - ret = [CBDescriptor version]; - } - return ret; - -} -void* -CBDescriptor_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [CBDescriptor debugDescription]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_ClassFallbacksForKeyedArchiver() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [CBDescriptor classFallbacksForKeyedArchiver]; - } - return ret; - -} -void* -CBDescriptor_AllocWithZone(void* zone) { - return [CBDescriptor allocWithZone:zone]; -} -BOOL -CBDescriptor_inst_ScriptingEndsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingEndsWith:object]; - } - return ret; - -} -BOOL -CBDescriptor_inst_IsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isGreaterThan:object]; - } - return ret; - -} -BOOL -CBDescriptor_inst_IsCaseInsensitiveLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isCaseInsensitiveLike:object]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingValueForSpecifier:objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_MutableSetValueForKey(void* o, void* key) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBDescriptor_inst_MutableCopy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableCopy]; - } - return ret; - -} -void -CBDescriptor_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBDescriptor*)o insertValue:value inPropertyWithKey:key]; - } -} -void -CBDescriptor_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBDescriptor*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void -CBDescriptor_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { - @autoreleasepool { - [(CBDescriptor*)o insertValue:value atIndex:index inPropertyWithKey:key]; - } -} -void* _Nullable -CBDescriptor_inst_CoerceValueForKey(void* o, void* value, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o coerceValue:value forKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBDescriptor_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBDescriptor_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBDescriptor_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; - for(int i=0;i<1;i++) { - if(ioValue[i] == 0) { break; } - [(id)ioValue[i] retain]; - } - - - for(int i=0;i<1;i++) { - if(outError[i] == 0) { break; } - [(id)outError[i] retain]; - } - - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingIsLessThanOrEqualTo:object]; - } - return ret; - -} -void -CBDescriptor_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { - @autoreleasepool { - [(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; - } -} -void -CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBDescriptor_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { - @autoreleasepool { - [(CBDescriptor*)o doesNotRecognizeSelector:aSelector]; - } -} -BOOL -CBDescriptor_inst_ScriptingIsGreaterThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingIsGreaterThan:object]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_ToOneRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o toOneRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingIsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingIsLessThan:object]; - } - return ret; - -} -void -CBDescriptor_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { - @autoreleasepool { - [(CBDescriptor*)o setValuesForKeysWithDictionary:keyedValues]; - } -} -void -CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBDescriptor*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void -CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { - @autoreleasepool { - [(CBDescriptor*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; - } -} -void* _Nullable -CBDescriptor_inst_ScriptingProperties(void* o) { - NSDictionary* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingProperties]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingBeginsWith(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingBeginsWith:object]; - } - return ret; - -} -void -CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { - @autoreleasepool { - [(CBDescriptor*)o removeValueAtIndex:index fromPropertyWithKey:key]; - } -} -BOOL -CBDescriptor_inst_DoesContain(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o doesContain:object]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ValueForUndefinedKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueForUndefinedKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingIsGreaterThanOrEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ClassForArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o classForArchiver]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_Characteristic(void* o) { - CBCharacteristic* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o characteristic]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { - @autoreleasepool { - [(CBDescriptor*)o removeObserver:observer forKeyPath:keyPath]; - } -} -void -CBDescriptor_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { - @autoreleasepool { - [(CBDescriptor*)o removeObserver:observer forKeyPath:keyPath context:context]; - } -} -BOOL -CBDescriptor_inst_IsLike(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isLike:object]; - } - return ret; - -} -void -CBDescriptor_inst_SetScriptingProperties(void* o, void* scriptingProperties) { - @autoreleasepool { - [(CBDescriptor*)o setScriptingProperties:scriptingProperties]; - } -} -BOOL -CBDescriptor_inst_IsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isEqualTo:object]; - } - return ret; - -} -void -CBDescriptor_inst_SetNilValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBDescriptor*)o setNilValueForKey:key]; - } -} -void* _Nonnull -CBDescriptor_inst_ClassDescription(void* o) { - NSClassDescription* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o classDescription]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBDescriptor*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBDescriptor_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBDescriptor*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -BOOL -CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; - } - return ret; - -} -void -CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void -CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { - @autoreleasepool { - [(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; - } -} -void* _Nullable -CBDescriptor_inst_ObjectSpecifier(void* o) { - NSScriptObjectSpecifier* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o objectSpecifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_MutableArrayValueForKey(void* o, void* key) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableArrayValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { - NSMutableSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o replacementObjectForKeyedArchiver:archiver]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_AutoContentAccessingProxy(void* o) { - NSObject* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o autoContentAccessingProxy]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -FourCharCode -CBDescriptor_inst_ClassCode(void* o) { - FourCharCode ret; - @autoreleasepool { - ret = [(CBDescriptor*)o classCode]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_ToManyRelationshipKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o toManyRelationshipKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingContains(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingContains:object]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o copyScriptingValue:value forKey:key withProperties:properties]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_ClassForCoder(void* o) { - Class _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o classForCoder]; - } - return ret; - -} -void -CBDescriptor_inst_SetObservationInfo(void* o, void* observationInfo) { - @autoreleasepool { - [(CBDescriptor*)o setObservationInfo:observationInfo]; - } -} -void* _Nonnull -CBDescriptor_inst_UUID(void* o) { - CBUUID* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o UUID]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ValueForKeyPath(void* o, void* keyPath) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_IsGreaterThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isGreaterThanOrEqualTo:object]; - } - return ret; - -} -void -CBDescriptor_inst_ForwardInvocation(void* o, void* anInvocation) { - @autoreleasepool { - [(CBDescriptor*)o forwardInvocation:anInvocation]; - } -} -void -CBDescriptor_inst_SetValueForKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBDescriptor*)o setValue:value forKey:key]; - } -} -void -CBDescriptor_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { - @autoreleasepool { - [(CBDescriptor*)o setValue:value forKeyPath:keyPath]; - } -} -void -CBDescriptor_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { - @autoreleasepool { - [(CBDescriptor*)o setValue:value forUndefinedKey:key]; - } -} -void* -CBDescriptor_inst_ForwardingTargetForSelector(void* o, void* aSelector) { - NSObject* ret; - @autoreleasepool { - ret = [(CBDescriptor*)o forwardingTargetForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ValueForKey(void* o, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBDescriptor_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; - } -} -void -CBDescriptor_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; - } -} -void -CBDescriptor_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBDescriptor_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; - } -} -void -CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { - @autoreleasepool { - [(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; - } -} -void -CBDescriptor_inst_DidChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBDescriptor*)o didChangeValueForKey:key]; - } -} -void -CBDescriptor_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBDescriptor*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBDescriptor_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBDescriptor*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBDescriptor_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBDescriptor_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -void -CBDescriptor_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { - @autoreleasepool { - [(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context]; - } -} -BOOL -CBDescriptor_inst_IsLessThanOrEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isLessThanOrEqualTo:object]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_DictionaryWithValuesForKeys(void* o, void* keys) { - NSDictionary* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o dictionaryWithValuesForKeys:keys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBDescriptor*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void -CBDescriptor_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { - @autoreleasepool { - [(CBDescriptor*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; - } -} -void* -CBDescriptor_inst_Copy(void* o) { - NSObject* ret; - @autoreleasepool { - ret = [(CBDescriptor*)o copy]; - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableOrderedSetValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_IsNotEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isNotEqualTo:object]; - } - return ret; - -} -void -CBDescriptor_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { - @autoreleasepool { - [(CBDescriptor*)o performSelectorInBackground:aSelector withObject:arg]; - } -} -void* _Nullable -CBDescriptor_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueWithName:name inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ObservationInfo(void* o) { - void* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o observationInfo]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ReplacementObjectForCoder(void* o, void* aCoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o replacementObjectForCoder:aCoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBDescriptor_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -void -CBDescriptor_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) { - @autoreleasepool { - [(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; - } -} -BOOL -CBDescriptor_inst_IsLessThan(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o isLessThan:object]; - } - return ret; - -} -void -CBDescriptor_inst_WillChangeValueForKey(void* o, void* key) { - @autoreleasepool { - [(CBDescriptor*)o willChangeValueForKey:key]; - } -} -void -CBDescriptor_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBDescriptor*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void -CBDescriptor_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { - @autoreleasepool { - [(CBDescriptor*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; - } -} -void* _Nonnull -CBDescriptor_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { - NSMutableArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableArrayValueForKeyPath:keyPath]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -BOOL -CBDescriptor_inst_ScriptingIsEqualTo(void* o, void* object) { - BOOL ret; - @autoreleasepool { - ret = [(CBDescriptor*)o scriptingIsEqualTo:object]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueAtIndex:index inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { - NSString* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o inverseForRelationshipKey:relationshipKey]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_AttributeKeys(void* o) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o attributeKeys]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* -CBDescriptor_inst_MethodSignatureForSelector(void* o, void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [(CBDescriptor*)o methodSignatureForSelector:aSelector]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_Value(void* o) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o value]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ClassForKeyedArchiver(void* o) { - Class _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o classForKeyedArchiver]; - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_MutableOrderedSetValueForKey(void* o, void* key) { - NSMutableOrderedSet* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o mutableOrderedSetValueForKey:key]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nullable -CBDescriptor_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { - NSObject* _Nullable ret; - @autoreleasepool { - ret = [(CBDescriptor*)o awakeAfterUsingCoder:aDecoder]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void* _Nonnull -CBDescriptor_inst_ClassName(void* o) { - NSString* _Nonnull ret; - @autoreleasepool { - ret = [(CBDescriptor*)o className]; - if (ret != nil && ret != o) { [ret retain]; } - } - return ret; - -} -void -CBDescriptor_inst_Dealloc(void* o) { - @autoreleasepool { - [(CBDescriptor*)o dealloc]; - } -} -void* -NSArray_InstanceMethodSignatureForSelector(void* aSelector) { - NSMethodSignature* ret; - @autoreleasepool { - ret = [NSArray instanceMethodSignatureForSelector:aSelector]; - } - return ret; - -} -NSUInteger -NSArray_Hash() { - NSUInteger ret; - @autoreleasepool { - ret = [NSArray hash]; - } - return ret; - -} -void* _Nonnull -NSArray_Array() { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSArray array]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSArray_CopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSArray copyWithZone:zone]; - } - return ret; - -} -void* _Nonnull -NSArray_ArrayWithArray(void* array) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSArray arrayWithArray:array]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSArray_AllocWithZone(void* zone) { - return [NSArray allocWithZone:zone]; -} -BOOL -NSArray_ConformsToProtocol(void* protocol) { - BOOL ret; - @autoreleasepool { - ret = [NSArray conformsToProtocol:protocol]; - } - return ret; - -} -BOOL -NSArray_SupportsSecureCoding() { - BOOL ret; - @autoreleasepool { - ret = [NSArray supportsSecureCoding]; - } - return ret; - -} -void* _Nullable -NSArray_ArrayWithContentsOfFile(void* path) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [NSArray arrayWithContentsOfFile:path]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* -NSArray_Alloc() { - return [NSArray alloc]; -} -void -NSArray_Load() { - @autoreleasepool { - [NSArray load]; - } -} -void* -NSArray_MutableCopyWithZone(void* zone) { - NSObject* ret; - @autoreleasepool { - ret = [NSArray mutableCopyWithZone:zone]; - } - return ret; - -} -void -NSArray_CancelPreviousPerformRequestsWithTarget(void* aTarget) { - @autoreleasepool { - [NSArray cancelPreviousPerformRequestsWithTarget:aTarget]; - } -} -void -NSArray_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void -NSArray_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { - @autoreleasepool { - [NSArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; - } -} -void* -NSArray_DebugDescription() { - NSString* ret; - @autoreleasepool { - ret = [NSArray debugDescription]; - } - return ret; - -} -BOOL -NSArray_IsSubclassOfClass(void* aClass) { - BOOL ret; - @autoreleasepool { - ret = [NSArray isSubclassOfClass:aClass]; - } - return ret; - -} -void* _Nullable -NSArray_ArrayWithContentsOfURL(void* url) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [NSArray arrayWithContentsOfURL:url]; - if(ret != nil) { [ret retain]; } - } - return ret; - -} -void* _Nullable -NSArray_ArrayWithContentsOfURLError(void* url, void** error) { - NSArray* _Nullable ret; - @autoreleasepool { - ret = [NSArray arrayWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error]; - if(ret != nil) { [ret retain]; } - for(int i=0;i<1;i++) { - if(error[i] == 0) { break; } - [(id)error[i] retain]; - } - - } - return ret; - -} -void* -NSArray_New() { - NSArray* ret; - @autoreleasepool { - ret = [NSArray new]; - } - return ret; - -} -BOOL -NSArray_AccessInstanceVariablesDirectly() { - BOOL ret; - @autoreleasepool { - ret = [NSArray accessInstanceVariablesDirectly]; - } - return ret; - -} -BOOL -NSArray_AutomaticallyNotifiesObserversForKey(void* key) { - BOOL ret; - @autoreleasepool { - ret = [NSArray automaticallyNotifiesObserversForKey:key]; - } - return ret; - -} -void* _Nonnull -NSArray_KeyPathsForValuesAffectingValueForKey(void* key) { - NSSet* _Nonnull ret; - @autoreleasepool { - ret = [NSArray keyPathsForValuesAffectingValueForKey:key]; - } - return ret; - -} -void -NSArray_SetVersion(NSInteger aVersion) { - @autoreleasepool { - [NSArray setVersion:aVersion]; - } -} -void* -NSArray_Description() { - NSString* ret; - @autoreleasepool { - ret = [NSArray description]; - } - return ret; - -} -void* _Nonnull -NSArray_ClassForKeyedUnarchiver() { - Class _Nonnull ret; - @autoreleasepool { - ret = [NSArray classForKeyedUnarchiver]; - } - return ret; - -} -void* _Nonnull -NSArray_ArrayWithObjectsCount(void** objects, NSUInteger cnt) { - NSArray* _Nonnull ret; - @autoreleasepool { - ret = [NSArray arrayWithObjects:(id _Nonnull const* _Nonnull)objects count:cnt]; - if(ret != nil) { [ret retain]; } - for(int i=0;i _Nonnull const* _Nullable)keys count:cnt]; - if(ret != nil) { [ret retain]; } - for(int i=0;i _Nonnull const* _Nullable)keys count:cnt]; - for(int i=0;i _Nonnull const* _Nullable)keys count:cnt]; + if(ret != nil) { [ret retain]; } + for(int i=0;i _Nonnull const* _Nullable)keys count:cnt]; + for(int i=0;i* _Nullable* _Nullable)tokenRanges]; + if (ret != nil && ret != o) { [ret retain]; } + for(int i=0;i<1;i++) { + if(tokenRanges[i] == 0) { break; } + [(id)tokenRanges[i] retain]; + } + + } + return ret; + +} +void* _Nonnull +NSString_inst_LinguisticTagsInRangeSchemeOptions(void* o, NSRange range, void* scheme, NSLinguisticTaggerOptions options, void* orthography, void** tokenRanges) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o linguisticTagsInRange:range scheme:scheme options:options orthography:orthography tokenRanges:(NSArray * _Nullable* _Nullable)tokenRanges]; + if (ret != nil && ret != o) { [ret retain]; } + for(int i=0;i<1;i++) { + if(tokenRanges[i] == 0) { break; } + [(id)tokenRanges[i] retain]; + } + + } + return ret; + +} +void* _Nonnull +NSString_inst_PropertyList(void* o) { + NSObject* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o propertyList]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithContentsOfFileEncoding(void* o, void* path, NSStringEncoding enc, void** error) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithContentsOfFileUsedEncoding(void* o, void* path, void* enc, void** error) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithContentsOfFileEncodingError(void* o, void* path, NSStringEncoding enc, void** error) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithContentsOfFileUsedEncodingError(void* o, void* path, void* enc, void** error) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +void* _Nullable +NSString_inst_StringByApplyingTransformReverse(void* o, void* transform, BOOL reverse) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o stringByApplyingTransform:transform reverse:reverse]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByFoldingWithOptionsLocale(void* o, NSStringCompareOptions options, void* locale) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByFoldingWithOptions:options locale:locale]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByTrimmingCharactersInSet(void* o, void* set) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByTrimmingCharactersInSet:set]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueAtIndex:index inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_ObjectSpecifier(void* o) { + NSScriptObjectSpecifier* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o objectSpecifier]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o awakeAfterUsingCoder:aDecoder]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_SetNilValueForKey(void* o, void* key) { + @autoreleasepool { + [(NSString*)o setNilValueForKey:key]; + } +} +void* +NSString_inst_Self(void* o) { + NSString* ret; + @autoreleasepool { + ret = [(NSString*)o self]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_CapitalizedString(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o capitalizedString]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +long long +NSString_inst_LongLongValue(void* o) { + long long ret; + @autoreleasepool { + ret = [(NSString*)o longLongValue]; + } + return ret; + +} +void +NSString_inst_Dealloc(void* o) { + @autoreleasepool { + [(NSString*)o dealloc]; + } +} +NSUInteger +NSString_inst_RetainCount(void* o) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o retainCount]; + } + return ret; + +} +NSUInteger +NSString_inst_CompletePathIntoStringCaseSensitive(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray * _Nullable* _Nullable)outputArray filterTypes:filterTypes]; + for(int i=0;i<1;i++) { + if(outputName[i] == 0) { break; } + [(id)outputName[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outputArray[i] == 0) { break; } + [(id)outputArray[i] retain]; + } + + } + return ret; + +} +NSUInteger +NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray * _Nullable* _Nullable)outputArray filterTypes:filterTypes]; + for(int i=0;i<1;i++) { + if(outputName[i] == 0) { break; } + [(id)outputName[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outputArray[i] == 0) { break; } + [(id)outputArray[i] retain]; + } + + } + return ret; + +} +NSUInteger +NSString_inst_Length(void* o) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o length]; + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByAppendingFormat(void* o, void* format, void* object) { + NSObject** arr = object; + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByAppendingFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSItemProviderRepresentationVisibility +NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* o, void* typeIdentifier) { + NSItemProviderRepresentationVisibility ret; + @autoreleasepool { + ret = [(NSString*)o itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier]; + } + return ret; + +} +BOOL +NSString_inst_GetBytesMaxLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover]; + } + return ret; + +} +BOOL +NSString_inst_GetBytesMaxLengthUsedLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover]; + } + return ret; + +} +void* _Nullable +NSString_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueWithName:name inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByAbbreviatingWithTildeInPath(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByAbbreviatingWithTildeInPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSRange +NSString_inst_ParagraphRangeForRange(void* o, NSRange range) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o paragraphRangeForRange:range]; + } + return ret; + +} +NSComparisonResult +NSString_inst_LocalizedCompare(void* o, void* string) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o localizedCompare:string]; + } + return ret; + +} +void* _Nonnull +NSString_inst_ComponentsSeparatedByString(void* o, void* separator) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o componentsSeparatedByString:separator]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSComparisonResult +NSString_inst_CaseInsensitiveCompare(void* o, void* string) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o caseInsensitiveCompare:string]; + } + return ret; + +} +void +NSString_inst_GetParagraphStartEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) { + @autoreleasepool { + [(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range]; + } +} +void +NSString_inst_GetParagraphStartEndContentsEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) { + @autoreleasepool { + [(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range]; + } +} +NSComparisonResult +NSString_inst_Compare(void* o, void* string) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o compare:string]; + } + return ret; + +} +NSComparisonResult +NSString_inst_CompareOptions(void* o, void* string, NSStringCompareOptions mask) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o compare:string options:mask]; + } + return ret; + +} +NSComparisonResult +NSString_inst_CompareOptionsRange(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare]; + } + return ret; + +} +NSComparisonResult +NSString_inst_CompareOptionsRangeLocale(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare, void* locale) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare locale:locale]; + } + return ret; + +} +NSRange +NSString_inst_RangeOfComposedCharacterSequenceAtIndex(void* o, NSUInteger index) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o rangeOfComposedCharacterSequenceAtIndex:index]; + } + return ret; + +} +void* _Nonnull +NSString_inst_DecomposedStringWithCanonicalMapping(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o decomposedStringWithCanonicalMapping]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithBytesNoCopyLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer]; + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithBytesNoCopyLengthEncoding(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer]; + } + return ret; + +} +NSUInteger +NSString_inst_LengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o lengthOfBytesUsingEncoding:enc]; + } + return ret; + +} +void +NSString_inst_SetObservationInfo(void* o, void* observationInfo) { + @autoreleasepool { + [(NSString*)o setObservationInfo:observationInfo]; + } +} +BOOL +NSString_inst_IsGreaterThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isGreaterThanOrEqualTo:object]; + } + return ret; + +} +void* _Nullable +NSString_inst_ClassForKeyedArchiver(void* o) { + Class _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o classForKeyedArchiver]; + } + return ret; + +} +void +NSString_inst_WillChangeValueForKey(void* o, void* key) { + @autoreleasepool { + [(NSString*)o willChangeValueForKey:key]; + } +} +void +NSString_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void +NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void* _Nonnull +NSString_inst_Description(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o description]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +const void* _Nullable +NSString_inst_CStringUsingEncoding(void* o, NSStringEncoding encoding) { + const char* _Nullable ret; + @autoreleasepool { + ret = strdup([(NSString*)o cStringUsingEncoding:encoding]); + } + return ret; + +} +void* _Nonnull +NSString_inst_LocalizedCapitalizedString(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o localizedCapitalizedString]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_DoesContain(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o doesContain:object]; + } + return ret; + +} +void* _Nullable +NSString_inst_StringByAppendingPathExtension(void* o, void* str) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o stringByAppendingPathExtension:str]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_DataUsingEncoding(void* o, NSStringEncoding encoding) { + NSData* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o dataUsingEncoding:encoding]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_DataUsingEncodingAllowLossyConversion(void* o, NSStringEncoding encoding, BOOL lossy) { + NSData* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o dataUsingEncoding:encoding allowLossyConversion:lossy]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_InitWithString(void* o, void* aString) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o initWithString:aString]; + } + return ret; + +} +BOOL +NSString_inst_ScriptingIsEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o scriptingIsEqualTo:object]; + } + return ret; + +} +BOOL +NSString_inst_ContainsString(void* o, void* str) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o containsString:str]; + } + return ret; + +} +BOOL +NSString_inst_IsProxy(void* o) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isProxy]; + } + return ret; + +} +void* _Nullable +NSString_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o scriptingValueForSpecifier:objectSpecifier]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_ScriptingIsGreaterThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o scriptingIsGreaterThan:object]; + } + return ret; + +} +void* _Nonnull +NSString_inst_LastPathComponent(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o lastPathComponent]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_IsMemberOfClass(void* o, void* aClass) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isMemberOfClass:aClass]; + } + return ret; + +} +void* _Nonnull +NSString_inst_ComponentsSeparatedByCharactersInSet(void* o, void* separator) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o componentsSeparatedByCharactersInSet:separator]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_SubstringFromIndex(void* o, NSUInteger from) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o substringFromIndex:from]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_MutableArrayValueForKey(void* o, void* key) { + NSMutableArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o mutableArrayValueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_InitWithCharactersLength(void* o, void* characters, NSUInteger length) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o initWithCharacters:characters length:length]; + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByReplacingOccurrencesOfStringWithString(void* o, void* target, void* replacement) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_ClassName(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o className]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_GetCharacters(void* o, void* buffer) { + @autoreleasepool { + [(NSString*)o getCharacters:buffer]; + } +} +void +NSString_inst_GetCharactersRange(void* o, void* buffer, NSRange range) { + @autoreleasepool { + [(NSString*)o getCharacters:buffer range:range]; + } +} +void* +NSString_inst_Retain(void* o) { + NSString* ret; + @autoreleasepool { + ret = [(NSString*)o retain]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o scriptingIsLessThanOrEqualTo:object]; + } + return ret; + +} +void +NSString_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { + @autoreleasepool { + [(NSString*)o performSelectorInBackground:aSelector withObject:arg]; + } +} +void* _Nullable +NSString_inst_InitWithCoder(void* o, void* aDecoder) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithCoder:aDecoder]; + } + return ret; + +} +double +NSString_inst_DoubleValue(void* o) { + double ret; + @autoreleasepool { + ret = [(NSString*)o doubleValue]; + } + return ret; + +} +NSRange +NSString_inst_LineRangeForRange(void* o, NSRange range) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o lineRangeForRange:range]; + } + return ret; + +} +BOOL +NSString_inst_IsLessThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isLessThanOrEqualTo:object]; + } + return ret; + +} +void +NSString_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { + @autoreleasepool { + [(NSString*)o setValuesForKeysWithDictionary:keyedValues]; + } +} +void* _Nullable +NSString_inst_ClassForArchiver(void* o) { + Class _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o classForArchiver]; + } + return ret; + +} +BOOL +NSString_inst_ScriptingContains(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o scriptingContains:object]; + } + return ret; + +} +void* _Nonnull +NSString_inst_AutoContentAccessingProxy(void* o) { + NSObject* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o autoContentAccessingProxy]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSInteger +NSString_inst_IntegerValue(void* o) { + NSInteger ret; + @autoreleasepool { + ret = [(NSString*)o integerValue]; + } + return ret; + +} +BOOL +NSString_inst_WriteToURLAtomically(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +BOOL +NSString_inst_WriteToURLAtomicallyEncoding(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error]; + for(int i=0;i<1;i++) { + if(error[i] == 0) { break; } + [(id)error[i] retain]; + } + + } + return ret; + +} +BOOL +NSString_inst_IsAbsolutePath(void* o) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isAbsolutePath]; + } + return ret; + +} +BOOL +NSString_inst_IsEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isEqualTo:object]; + } + return ret; + +} +void* _Nullable +NSString_inst_ValueForKey(void* o, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_PrecomposedStringWithCanonicalMapping(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o precomposedStringWithCanonicalMapping]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_IsLessThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isLessThan:object]; + } + return ret; + +} +void* _Nonnull +NSString_inst_SubstringToIndex(void* o, NSUInteger to) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o substringToIndex:to]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_ValueForKeyPath(void* o, void* keyPath) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueForKeyPath:keyPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_CopyWithZone(void* o, void* zone) { + NSObject* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o copyWithZone:zone]; + } + return ret; + +} +void* _Nonnull +NSString_inst_PrecomposedStringWithCompatibilityMapping(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o precomposedStringWithCompatibilityMapping]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_GetFileSystemRepresentationMaxLength(void* o, void* cname, NSUInteger max) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o getFileSystemRepresentation:cname maxLength:max]; + } + return ret; + +} +void* _Nullable +NSString_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; + } + return ret; + +} +void* _Nullable +NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; + } + return ret; + +} +void* _Nonnull +NSString_inst_PathExtension(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o pathExtension]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSString_inst_Zone(void* o) { + struct _NSZone* ret; + @autoreleasepool { + ret = [(NSString*)o zone]; + } + return ret; + +} +void* _Nonnull +NSString_inst_WritableTypeIdentifiersForItemProvider(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o writableTypeIdentifiersForItemProvider]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSString_inst_Copy(void* o) { + NSObject* ret; + @autoreleasepool { + ret = [(NSString*)o copy]; + } + return ret; + +} +NSUInteger +NSString_inst_MaximumLengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSString*)o maximumLengthOfBytesUsingEncoding:enc]; + } + return ret; + +} +void* _Nullable +NSString_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o replacementObjectForKeyedArchiver:archiver]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_SetValueForKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSString*)o setValue:value forKey:key]; + } +} +void +NSString_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { + @autoreleasepool { + [(NSString*)o setValue:value forKeyPath:keyPath]; + } +} +void +NSString_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSString*)o setValue:value forUndefinedKey:key]; + } +} +void* _Nonnull +NSString_inst_UppercaseString(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o uppercaseString]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSComparisonResult +NSString_inst_LocalizedCaseInsensitiveCompare(void* o, void* string) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o localizedCaseInsensitiveCompare:string]; + } + return ret; + +} +void +NSString_inst_Release(void* o) { + @autoreleasepool { + [(NSString*)o release]; + } +} +void* _Nonnull +NSString_inst_PathComponents(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o pathComponents]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(void* o, void* allowedCharacters) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o stringByAddingPercentEncodingWithAllowedCharacters:allowedCharacters]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_SetScriptingProperties(void* o, void* scriptingProperties) { + @autoreleasepool { + [(NSString*)o setScriptingProperties:scriptingProperties]; + } +} +void* _Nonnull +NSString_inst_StringByAppendingString(void* o, void* aString) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByAppendingString:aString]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSString_inst_MutableCopy(void* o) { + NSObject* ret; + @autoreleasepool { + ret = [(NSString*)o mutableCopy]; + } + return ret; + +} +float +NSString_inst_FloatValue(void* o) { + float ret; + @autoreleasepool { + ret = [(NSString*)o floatValue]; + } + return ret; + +} +const void* _Nonnull +NSString_inst_FileSystemRepresentation(void* o) { + const char* _Nonnull ret; + @autoreleasepool { + ret = strdup([(NSString*)o fileSystemRepresentation]); + } + return ret; + +} +void* _Nonnull +NSString_inst_StringByExpandingTildeInPath(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o stringByExpandingTildeInPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSString_inst_DebugDescription(void* o) { + NSString* ret; + @autoreleasepool { + ret = [(NSString*)o debugDescription]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSString_inst_IsEqual(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isEqual:object]; + } + return ret; + +} +void* _Nullable +NSString_inst_ValueForUndefinedKey(void* o, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o valueForUndefinedKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_ToOneRelationshipKeys(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o toOneRelationshipKeys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSString_inst_StringByRemovingPercentEncoding(void* o) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o stringByRemovingPercentEncoding]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSString_inst_Class(void* o) { + Class ret; + @autoreleasepool { + ret = [(NSString*)o class]; + } + return ret; + +} +void +NSString_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { + @autoreleasepool { + [(NSString*)o removeValueAtIndex:index fromPropertyWithKey:key]; + } +} +void* _Nonnull +NSString_inst_InitWithFormat(void* o, void* format, void* object) { + NSObject** arr = object; + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o initWithFormat:format , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; + } + return ret; + +} +void* _Nonnull +NSString_inst_InitWithFormatLocale(void* o, void* format, void* locale, void* object) { + NSObject** arr = object; + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o initWithFormat:format locale:locale , arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9], arr[10], arr[11], arr[12], arr[13], arr[14], arr[15], nil]; + } + return ret; + +} +BOOL +NSString_inst_LocalizedCaseInsensitiveContainsString(void* o, void* str) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o localizedCaseInsensitiveContainsString:str]; + } + return ret; + +} +BOOL +NSString_inst_IsGreaterThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isGreaterThan:object]; + } + return ret; + +} +void* _Nullable +NSString_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties]; + } + return ret; + +} +void* _Nullable +NSString_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties]; + } + return ret; + +} +void* _Nullable +NSString_inst_ReplacementObjectForCoder(void* o, void* aCoder) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o replacementObjectForCoder:aCoder]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSString_inst_Init(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o init]; + } + return ret; + +} +BOOL +NSString_inst_CanBeConvertedToEncoding(void* o, NSStringEncoding encoding) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o canBeConvertedToEncoding:encoding]; + } + return ret; + +} +BOOL +NSString_inst_IsEqualToString(void* o, void* aString) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o isEqualToString:aString]; + } + return ret; + +} +void* _Nonnull +NSString_inst_DictionaryWithValuesForKeys(void* o, void* keys) { + NSDictionary* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o dictionaryWithValuesForKeys:keys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSComparisonResult +NSString_inst_LocalizedStandardCompare(void* o, void* string) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSString*)o localizedStandardCompare:string]; + } + return ret; + +} +void +NSString_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { + @autoreleasepool { + [(NSString*)o removeObserver:observer forKeyPath:keyPath]; + } +} +void +NSString_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { + @autoreleasepool { + [(NSString*)o removeObserver:observer forKeyPath:keyPath context:context]; + } +} +FourCharCode +NSString_inst_ClassCode(void* o) { + FourCharCode ret; + @autoreleasepool { + ret = [(NSString*)o classCode]; + } + return ret; + +} +int +NSString_inst_IntValue(void* o) { + int ret; + @autoreleasepool { + ret = [(NSString*)o intValue]; + } + return ret; + +} +void* +NSString_inst_Superclass(void* o) { + Class ret; + @autoreleasepool { + ret = [(NSString*)o superclass]; + } + return ret; + +} +void* +NSString_inst_MethodSignatureForSelector(void* o, void* aSelector) { + NSMethodSignature* ret; + @autoreleasepool { + ret = [(NSString*)o methodSignatureForSelector:aSelector]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSString*)o insertValue:value inPropertyWithKey:key]; + } +} +void +NSString_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { + @autoreleasepool { + [(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key]; + } +} +void +NSString_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { + @autoreleasepool { + [(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key]; + } +} +BOOL +NSString_inst_ScriptingEndsWith(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSString*)o scriptingEndsWith:object]; + } + return ret; + +} +void* _Nonnull +NSString_inst_MutableOrderedSetValueForKey(void* o, void* key) { + NSMutableOrderedSet* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o mutableOrderedSetValueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSRange +NSString_inst_RangeOfCharacterFromSet(void* o, void* searchSet) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o rangeOfCharacterFromSet:searchSet]; + } + return ret; + +} +NSRange +NSString_inst_RangeOfCharacterFromSetOptions(void* o, void* searchSet, NSStringCompareOptions mask) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask]; + } + return ret; + +} +NSRange +NSString_inst_RangeOfCharacterFromSetOptionsRange(void* o, void* searchSet, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch) { + NSRange ret; + @autoreleasepool { + ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask range:rangeOfReceiverToSearch]; + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithBytesLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding]; + } + return ret; + +} +void* _Nullable +NSString_inst_InitWithBytesLengthEncoding(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding]; + } + return ret; + +} +void* _Nonnull +NSString_inst_SubstringWithRange(void* o, NSRange range) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSString*)o substringWithRange:range]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSString_inst_ForwardInvocation(void* o, void* anInvocation) { + @autoreleasepool { + [(NSString*)o forwardInvocation:anInvocation]; + } +} +void* _Nonnull +NSNumber_ValueWithNonretainedObject(void* anObject) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithNonretainedObject:anObject]; + } + return ret; + +} +void* +NSNumber_New() { + NSNumber* ret; + @autoreleasepool { + ret = [NSNumber new]; + } + return ret; + +} +void* _Nonnull +NSNumber_KeyPathsForValuesAffectingValueForKey(void* key) { + NSSet* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber keyPathsForValuesAffectingValueForKey:key]; + } + return ret; + +} +void +NSNumber_CancelPreviousPerformRequestsWithTarget(void* aTarget) { + @autoreleasepool { + [NSNumber cancelPreviousPerformRequestsWithTarget:aTarget]; + } +} +void +NSNumber_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) { + @autoreleasepool { + [NSNumber cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; + } +} +void +NSNumber_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) { + @autoreleasepool { + [NSNumber cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument]; + } +} +void* _Nonnull +NSNumber_NumberWithFloat(float value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithFloat:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithDouble(double value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithDouble:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithChar(char value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithChar:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithRect(NSRect rect) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithRect:rect]; + } + return ret; + +} +void* +NSNumber_AllocWithZone(void* zone) { + return [NSNumber allocWithZone:zone]; +} +void* +NSNumber_Description() { + NSString* ret; + @autoreleasepool { + ret = [NSNumber description]; + } + return ret; + +} +void +NSNumber_Load() { + @autoreleasepool { + [NSNumber load]; + } +} +void* +NSNumber_DebugDescription() { + NSString* ret; + @autoreleasepool { + ret = [NSNumber debugDescription]; + } + return ret; + +} +void* +NSNumber_Superclass() { + Class ret; + @autoreleasepool { + ret = [NSNumber superclass]; + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithInt(int value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithInt:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithShort(short value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithShort:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithBytesObjCType(void* value, void* type) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithBytes:value objCType:type]; + } + return ret; + +} +BOOL +NSNumber_ResolveClassMethod(void* sel) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber resolveClassMethod:sel]; + } + return ret; + +} +void* _Nonnull +NSNumber_ClassFallbacksForKeyedArchiver() { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber classFallbacksForKeyedArchiver]; + } + return ret; + +} +BOOL +NSNumber_ConformsToProtocol(void* protocol) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber conformsToProtocol:protocol]; + } + return ret; + +} +NSUInteger +NSNumber_Hash() { + NSUInteger ret; + @autoreleasepool { + ret = [NSNumber hash]; + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedInt(unsigned int value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedInt:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedInteger(NSUInteger value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedInteger:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedLong(unsigned long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedLong:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedChar(unsigned char value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedChar:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_InstanceMethodSignatureForSelector(void* aSelector) { + NSMethodSignature* ret; + @autoreleasepool { + ret = [NSNumber instanceMethodSignatureForSelector:aSelector]; + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedLongLong(unsigned long long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedLongLong:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithUnsignedShort(unsigned short value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithUnsignedShort:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_MutableCopyWithZone(void* zone) { + NSObject* ret; + @autoreleasepool { + ret = [NSNumber mutableCopyWithZone:zone]; + } + return ret; + +} +BOOL +NSNumber_InstancesRespondToSelector(void* aSelector) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber instancesRespondToSelector:aSelector]; + } + return ret; + +} +void* _Nonnull +NSNumber_ClassForKeyedUnarchiver() { + Class _Nonnull ret; + @autoreleasepool { + ret = [NSNumber classForKeyedUnarchiver]; + } + return ret; + +} +BOOL +NSNumber_IsSubclassOfClass(void* aClass) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber isSubclassOfClass:aClass]; + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithPoint(NSPoint point) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithPoint:point]; + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithObjCType(void* value, void* type) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber value:value withObjCType:type]; + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithRange(NSRange range) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithRange:range]; + } + return ret; + +} +NSInteger +NSNumber_Version() { + NSInteger ret; + @autoreleasepool { + ret = [NSNumber version]; + } + return ret; + +} +void* +NSNumber_Alloc() { + return [NSNumber alloc]; +} +BOOL +NSNumber_ResolveInstanceMethod(void* sel) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber resolveInstanceMethod:sel]; + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithInteger(NSInteger value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithInteger:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithBool(BOOL value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithBool:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_Class() { + Class ret; + @autoreleasepool { + ret = [NSNumber class]; + } + return ret; + +} +void* +NSNumber_CopyWithZone(void* zone) { + NSObject* ret; + @autoreleasepool { + ret = [NSNumber copyWithZone:zone]; + } + return ret; + +} +void* _Nonnull +NSNumber_NumberWithLong(long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithLong:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithSize(NSSize size) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithSize:size]; + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithEdgeInsets(NSEdgeInsets insets) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithEdgeInsets:insets]; + } + return ret; + +} +void +NSNumber_SetVersion(NSInteger aVersion) { + @autoreleasepool { + [NSNumber setVersion:aVersion]; + } +} +void* _Nonnull +NSNumber_NumberWithLongLong(long long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber numberWithLongLong:value]; + if(ret != nil) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_ValueWithPointer(void* pointer) { + NSValue* _Nonnull ret; + @autoreleasepool { + ret = [NSNumber valueWithPointer:pointer]; + } + return ret; + +} +BOOL +NSNumber_AccessInstanceVariablesDirectly() { + BOOL ret; + @autoreleasepool { + ret = [NSNumber accessInstanceVariablesDirectly]; + } + return ret; + +} +BOOL +NSNumber_AutomaticallyNotifiesObserversForKey(void* key) { + BOOL ret; + @autoreleasepool { + ret = [NSNumber automaticallyNotifiesObserversForKey:key]; + } + return ret; + +} +void +NSNumber_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { + @autoreleasepool { + [(NSNumber*)o addObserver:observer forKeyPath:keyPath options:options context:context]; + } +} +void +NSNumber_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) { + @autoreleasepool { + [(NSNumber*)o addObserver:observer forKeyPath:keyPath options:options context:context]; + } +} +void* _Nonnull +NSNumber_inst_MutableArrayValueForKey(void* o, void* key) { + NSMutableArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableArrayValueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingIsEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingIsEqualTo:object]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ValueForKeyPath(void* o, void* keyPath) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueForKeyPath:keyPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingIsGreaterThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingIsGreaterThan:object]; + } + return ret; + +} +unsigned char +NSNumber_inst_UnsignedCharValue(void* o) { + unsigned char ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedCharValue]; + } + return ret; + +} +NSUInteger +NSNumber_inst_RetainCount(void* o) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSNumber*)o retainCount]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_StringValue(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o stringValue]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSNumber_inst_ValueForKey(void* o, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_SetObservationInfo(void* o, void* observationInfo) { + @autoreleasepool { + [(NSNumber*)o setObservationInfo:observationInfo]; + } +} +void +NSNumber_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) { + @autoreleasepool { + [(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; + } +} +void +NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) { + @autoreleasepool { + [(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait]; + } +} +void +NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) { + @autoreleasepool { + [(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array]; + } +} +void* _Nonnull +NSNumber_inst_InitWithInteger(void* o, NSInteger value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithInteger:value]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithFloat(void* o, float value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithFloat:value]; + } + return ret; + +} +NSRect +NSNumber_inst_RectValue(void* o) { + NSRect ret; + @autoreleasepool { + ret = [(NSNumber*)o rectValue]; + } + return ret; + +} +void +NSNumber_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) { + @autoreleasepool { + [(NSNumber*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; + } +} +void +NSNumber_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) { + @autoreleasepool { + [(NSNumber*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context]; + } +} +void* +NSNumber_inst_DebugDescription(void* o) { + NSString* ret; + @autoreleasepool { + ret = [(NSNumber*)o debugDescription]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_PerformSelector(void* o, void* aSelector) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o performSelector:aSelector]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o performSelector:aSelector withObject:object]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o performSelector:aSelector withObject:object1 withObject:object2]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay]; + } +} +void +NSNumber_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; + } +} +void +NSNumber_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes]; + } +} +void +NSNumber_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait]; + } +} +void +NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; + } +} +void +NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) { + @autoreleasepool { + [(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array]; + } +} +void +NSNumber_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { + @autoreleasepool { + [(NSNumber*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; + } +} +void +NSNumber_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { + @autoreleasepool { + [(NSNumber*)o willChange:changeKind valuesAtIndexes:indexes forKey:key]; + } +} +BOOL +NSNumber_inst_ScriptingBeginsWith(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingBeginsWith:object]; + } + return ret; + +} +NSComparisonResult +NSNumber_inst_Compare(void* o, void* otherNumber) { + NSComparisonResult ret; + @autoreleasepool { + ret = [(NSNumber*)o compare:otherNumber]; + } + return ret; + +} +BOOL +NSNumber_inst_IsEqualToNumber(void* o, void* number) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isEqualToNumber:number]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithBytesObjCType(void* o, void* value, void* type) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithBytes:value objCType:type]; + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingIsGreaterThanOrEqualTo:object]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ReplacementObjectForCoder(void* o, void* aCoder) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o replacementObjectForCoder:aCoder]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_ToManyRelationshipKeys(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o toManyRelationshipKeys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_ForwardInvocation(void* o, void* anInvocation) { + @autoreleasepool { + [(NSNumber*)o forwardInvocation:anInvocation]; + } +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedChar(void* o, unsigned char value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedChar:value]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithChar(void* o, char value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithChar:value]; + } + return ret; + +} +NSUInteger +NSNumber_inst_UnsignedIntegerValue(void* o) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedIntegerValue]; + } + return ret; + +} +void +NSNumber_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { + @autoreleasepool { + [(NSNumber*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; + } +} +void +NSNumber_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) { + @autoreleasepool { + [(NSNumber*)o didChange:changeKind valuesAtIndexes:indexes forKey:key]; + } +} +void* _Nonnull +NSNumber_inst_InitWithInt(void* o, int value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithInt:value]; + } + return ret; + +} +unsigned long long +NSNumber_inst_UnsignedLongLongValue(void* o) { + unsigned long long ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedLongLongValue]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueWithUniqueID:uniqueID inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSNumber_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o replacementObjectForKeyedArchiver:archiver]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_MutableSetValueForKeyPath(void* o, void* keyPath) { + NSMutableSet* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableSetValueForKeyPath:keyPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingIsLessThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingIsLessThan:object]; + } + return ret; + +} +void* +NSNumber_inst_Description(void* o) { + NSString* ret; + @autoreleasepool { + ret = [(NSNumber*)o description]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithLong(void* o, long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithLong:value]; + } + return ret; + +} +unsigned int +NSNumber_inst_UnsignedIntValue(void* o) { + unsigned int ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedIntValue]; + } + return ret; + +} +NSPoint +NSNumber_inst_PointValue(void* o) { + NSPoint ret; + @autoreleasepool { + ret = [(NSNumber*)o pointValue]; + } + return ret; + +} +BOOL +NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex]; + } + return ret; + +} +void +NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { + @autoreleasepool { + [(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; + } +} +void +NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) { + @autoreleasepool { + [(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo]; + } +} +void* _Nonnull +NSNumber_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) { + NSMutableOrderedSet* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableOrderedSetValueForKeyPath:keyPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) { + @autoreleasepool { + [(NSNumber*)o performSelectorInBackground:aSelector withObject:arg]; + } +} +void* _Nullable +NSNumber_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueWithName:name inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_IsGreaterThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isGreaterThan:object]; + } + return ret; + +} +void +NSNumber_inst_Release(void* o) { + @autoreleasepool { + [(NSNumber*)o release]; + } +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedInt(void* o, unsigned int value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedInt:value]; + } + return ret; + +} +double +NSNumber_inst_DoubleValue(void* o) { + double ret; + @autoreleasepool { + ret = [(NSNumber*)o doubleValue]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingValueForSpecifier:objectSpecifier]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSNumber_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueAtIndex:index inPropertyWithKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_IsKindOfClass(void* o, void* aClass) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isKindOfClass:aClass]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_ClassName(void* o) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o className]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_SetNilValueForKey(void* o, void* key) { + @autoreleasepool { + [(NSNumber*)o setNilValueForKey:key]; + } +} +void* _Nonnull +NSNumber_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) { + NSMutableArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableArrayValueForKeyPath:keyPath]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_ForwardingTargetForSelector(void* o, void* aSelector) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o forwardingTargetForSelector:aSelector]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_DoesContain(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o doesContain:object]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties]; + } + return ret; + +} +void +NSNumber_inst_SetScriptingProperties(void* o, void* scriptingProperties) { + @autoreleasepool { + [(NSNumber*)o setScriptingProperties:scriptingProperties]; + } +} +void* _Nullable +NSNumber_inst_CoerceValueForKey(void* o, void* value, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o coerceValue:value forKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_IsCaseInsensitiveLike(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isCaseInsensitiveLike:object]; + } + return ret; + +} +FourCharCode +NSNumber_inst_ClassCode(void* o) { + FourCharCode ret; + @autoreleasepool { + ret = [(NSNumber*)o classCode]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedInteger(void* o, NSUInteger value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedInteger:value]; + } + return ret; + +} +const void* _Nonnull +NSNumber_inst_ObjCType(void* o) { + const char* _Nonnull ret; + @autoreleasepool { + ret = strdup([(NSNumber*)o objCType]); + } + return ret; + +} +BOOL +NSNumber_inst_IsEqualToValue(void* o, void* value) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isEqualToValue:value]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_InverseForRelationshipKey(void* o, void* relationshipKey) { + NSString* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o inverseForRelationshipKey:relationshipKey]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +int +NSNumber_inst_IntValue(void* o) { + int ret; + @autoreleasepool { + ret = [(NSNumber*)o intValue]; + } + return ret; + +} +BOOL +NSNumber_inst_IsNotEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isNotEqualTo:object]; + } + return ret; + +} +BOOL +NSNumber_inst_IsProxy(void* o) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isProxy]; + } + return ret; + +} +void* +NSNumber_inst_Init(void* o) { + NSNumber* ret; + @autoreleasepool { + ret = [(NSNumber*)o init]; + } + return ret; + +} +BOOL +NSNumber_inst_IsMemberOfClass(void* o, void* aClass) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isMemberOfClass:aClass]; + } + return ret; + +} +void* +NSNumber_inst_MethodSignatureForSelector(void* o, void* aSelector) { + NSMethodSignature* ret; + @autoreleasepool { + ret = [(NSNumber*)o methodSignatureForSelector:aSelector]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSNumber_inst_AwakeAfterUsingCoder(void* o, void* aDecoder) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o awakeAfterUsingCoder:aDecoder]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_ConformsToProtocol(void* o, void* aProtocol) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o conformsToProtocol:aProtocol]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ValueForUndefinedKey(void* o, void* key) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o valueForUndefinedKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_MutableOrderedSetValueForKey(void* o, void* key) { + NSMutableOrderedSet* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableOrderedSetValueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedShort(void* o, unsigned short value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedShort:value]; + } + return ret; + +} +unsigned short +NSNumber_inst_UnsignedShortValue(void* o) { + unsigned short ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedShortValue]; + } + return ret; + +} +void* +NSNumber_inst_Autorelease(void* o) { + NSNumber* ret; + @autoreleasepool { + ret = [(NSNumber*)o autorelease]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_Superclass(void* o) { + Class ret; + @autoreleasepool { + ret = [(NSNumber*)o superclass]; + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingContains(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingContains:object]; + } + return ret; + +} +BOOL +NSNumber_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; + for(int i=0;i<1;i++) { + if(ioValue[i] == 0) { break; } + [(id)ioValue[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outError[i] == 0) { break; } + [(id)outError[i] retain]; + } + + } + return ret; + +} +BOOL +NSNumber_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; + for(int i=0;i<1;i++) { + if(ioValue[i] == 0) { break; } + [(id)ioValue[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outError[i] == 0) { break; } + [(id)outError[i] retain]; + } + + } + return ret; + +} +BOOL +NSNumber_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError]; + for(int i=0;i<1;i++) { + if(ioValue[i] == 0) { break; } + [(id)ioValue[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outError[i] == 0) { break; } + [(id)outError[i] retain]; + } + + } + return ret; + +} +BOOL +NSNumber_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError]; + for(int i=0;i<1;i++) { + if(ioValue[i] == 0) { break; } + [(id)ioValue[i] retain]; + } + + + for(int i=0;i<1;i++) { + if(outError[i] == 0) { break; } + [(id)outError[i] retain]; + } + + } + return ret; + +} +BOOL +NSNumber_inst_IsEqual(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isEqual:object]; + } + return ret; + +} +float +NSNumber_inst_FloatValue(void* o) { + float ret; + @autoreleasepool { + ret = [(NSNumber*)o floatValue]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_InitWithCoder(void* o, void* aDecoder) { + NSNumber* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithCoder:aDecoder]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_NonretainedObjectValue(void* o) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o nonretainedObjectValue]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +NSSize +NSNumber_inst_SizeValue(void* o) { + NSSize ret; + @autoreleasepool { + ret = [(NSNumber*)o sizeValue]; + } + return ret; + +} +BOOL +NSNumber_inst_IsLike(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isLike:object]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_AutoContentAccessingProxy(void* o) { + NSObject* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o autoContentAccessingProxy]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +short +NSNumber_inst_ShortValue(void* o) { + short ret; + @autoreleasepool { + ret = [(NSNumber*)o shortValue]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_DescriptionWithLocale(void* o, void* locale) { + NSString* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o descriptionWithLocale:locale]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nullable +NSNumber_inst_ClassForArchiver(void* o) { + Class _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o classForArchiver]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o copyScriptingValue:value forKey:key withProperties:properties]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) { + NSObject* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o copyScriptingValue:value forKey:key withProperties:properties]; + } + return ret; + +} +void +NSNumber_inst_WillChangeValueForKey(void* o, void* key) { + @autoreleasepool { + [(NSNumber*)o willChangeValueForKey:key]; + } +} +void +NSNumber_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSNumber*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void +NSNumber_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSNumber*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void* +NSNumber_inst_Self(void* o) { + NSNumber* ret; + @autoreleasepool { + ret = [(NSNumber*)o self]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +long long +NSNumber_inst_LongLongValue(void* o) { + long long ret; + @autoreleasepool { + ret = [(NSNumber*)o longLongValue]; + } + return ret; + +} +NSInteger +NSNumber_inst_IntegerValue(void* o) { + NSInteger ret; + @autoreleasepool { + ret = [(NSNumber*)o integerValue]; + } + return ret; + +} +void +NSNumber_inst_DidChangeValueForKey(void* o, void* key) { + @autoreleasepool { + [(NSNumber*)o didChangeValueForKey:key]; + } +} +void +NSNumber_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSNumber*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void +NSNumber_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) { + @autoreleasepool { + [(NSNumber*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects]; + } +} +void* _Nonnull +NSNumber_inst_InitWithLongLong(void* o, long long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithLongLong:value]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedLong(void* o, unsigned long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedLong:value]; + } + return ret; + +} +NSEdgeInsets +NSNumber_inst_EdgeInsetsValue(void* o) { + NSEdgeInsets ret; + @autoreleasepool { + ret = [(NSNumber*)o edgeInsetsValue]; + } + return ret; + +} +void +NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) { + @autoreleasepool { + [(NSNumber*)o removeValueAtIndex:index fromPropertyWithKey:key]; + } +} +unsigned long +NSNumber_inst_UnsignedLongValue(void* o) { + unsigned long ret; + @autoreleasepool { + ret = [(NSNumber*)o unsignedLongValue]; + } + return ret; + +} +long +NSNumber_inst_LongValue(void* o) { + long ret; + @autoreleasepool { + ret = [(NSNumber*)o longValue]; + } + return ret; + +} +BOOL +NSNumber_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingIsLessThanOrEqualTo:object]; + } + return ret; + +} +void +NSNumber_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) { + @autoreleasepool { + [(NSNumber*)o removeObserver:observer forKeyPath:keyPath]; + } +} +void +NSNumber_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) { + @autoreleasepool { + [(NSNumber*)o removeObserver:observer forKeyPath:keyPath context:context]; + } +} +void +NSNumber_inst_SetValueForKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSNumber*)o setValue:value forKey:key]; + } +} +void +NSNumber_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) { + @autoreleasepool { + [(NSNumber*)o setValue:value forKeyPath:keyPath]; + } +} +void +NSNumber_inst_SetValueForUndefinedKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSNumber*)o setValue:value forUndefinedKey:key]; + } +} +void* _Nonnull +NSNumber_inst_InitWithShort(void* o, short value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithShort:value]; + } + return ret; + +} +void* +NSNumber_inst_Copy(void* o) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o copy]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ObservationInfo(void* o) { + void* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o observationInfo]; + } + return ret; + +} +void +NSNumber_inst_DoesNotRecognizeSelector(void* o, void* aSelector) { + @autoreleasepool { + [(NSNumber*)o doesNotRecognizeSelector:aSelector]; + } +} +void* +NSNumber_inst_Zone(void* o) { + struct _NSZone* ret; + @autoreleasepool { + ret = [(NSNumber*)o zone]; + } + return ret; + +} +char +NSNumber_inst_CharValue(void* o) { + char ret; + @autoreleasepool { + ret = [(NSNumber*)o charValue]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_PointerValue(void* o) { + void* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o pointerValue]; + } + return ret; + +} +NSUInteger +NSNumber_inst_Hash(void* o) { + NSUInteger ret; + @autoreleasepool { + ret = [(NSNumber*)o hash]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithBool(void* o, BOOL value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithBool:value]; + } + return ret; + +} +void +NSNumber_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) { + @autoreleasepool { + [(NSNumber*)o setValuesForKeysWithDictionary:keyedValues]; + } +} +void* +NSNumber_inst_MutableCopy(void* o) { + NSObject* ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableCopy]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ClassForKeyedArchiver(void* o) { + Class _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o classForKeyedArchiver]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_AttributeKeys(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o attributeKeys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_DictionaryWithValuesForKeys(void* o, void* keys) { + NSDictionary* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o dictionaryWithValuesForKeys:keys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_MutableSetValueForKey(void* o, void* key) { + NSMutableSet* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o mutableSetValueForKey:key]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_Retain(void* o) { + NSNumber* ret; + @autoreleasepool { + ret = [(NSNumber*)o retain]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* +NSNumber_inst_Class(void* o) { + Class ret; + @autoreleasepool { + ret = [(NSNumber*)o class]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ScriptingProperties(void* o) { + NSDictionary* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingProperties]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void* _Nonnull +NSNumber_inst_ClassForCoder(void* o) { + Class _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o classForCoder]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_ToOneRelationshipKeys(void* o) { + NSArray* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o toOneRelationshipKeys]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_IsGreaterThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isGreaterThanOrEqualTo:object]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithDouble(void* o, double value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithDouble:value]; + } + return ret; + +} +void* _Nonnull +NSNumber_inst_InitWithUnsignedLongLong(void* o, unsigned long long value) { + NSNumber* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o initWithUnsignedLongLong:value]; + } + return ret; + +} +BOOL +NSNumber_inst_IsEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isEqualTo:object]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_ObjectSpecifier(void* o) { + NSScriptObjectSpecifier* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o objectSpecifier]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_Dealloc(void* o) { + @autoreleasepool { + [(NSNumber*)o dealloc]; + } +} +BOOL +NSNumber_inst_IsLessThan(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isLessThan:object]; + } + return ret; + +} +void +NSNumber_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) { + @autoreleasepool { + [(NSNumber*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; + } +} +void +NSNumber_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) { + @autoreleasepool { + [(NSNumber*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value]; + } +} +NSRange +NSNumber_inst_RangeValue(void* o) { + NSRange ret; + @autoreleasepool { + ret = [(NSNumber*)o rangeValue]; + } + return ret; + +} +void +NSNumber_inst_GetValue(void* o, void* value) { + @autoreleasepool { + [(NSNumber*)o getValue:value]; + } +} +void +NSNumber_inst_GetValueSize(void* o, void* value, NSUInteger size) { + @autoreleasepool { + [(NSNumber*)o getValue:value size:size]; + } +} +void* _Nonnull +NSNumber_inst_ClassDescription(void* o) { + NSClassDescription* _Nonnull ret; + @autoreleasepool { + ret = [(NSNumber*)o classDescription]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +void +NSNumber_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) { + @autoreleasepool { + [(NSNumber*)o insertValue:value inPropertyWithKey:key]; + } +} +void +NSNumber_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) { + @autoreleasepool { + [(NSNumber*)o insertValue:value atIndex:index inPropertyWithKey:key]; + } +} +void +NSNumber_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) { + @autoreleasepool { + [(NSNumber*)o insertValue:value atIndex:index inPropertyWithKey:key]; + } +} +BOOL +NSNumber_inst_ScriptingEndsWith(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o scriptingEndsWith:object]; + } + return ret; + +} +BOOL +NSNumber_inst_BoolValue(void* o) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o boolValue]; + } + return ret; + +} +BOOL +NSNumber_inst_RespondsToSelector(void* o, void* aSelector) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o respondsToSelector:aSelector]; + } + return ret; + +} +void* _Nullable +NSNumber_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) { + NSArray* _Nullable ret; + @autoreleasepool { + ret = [(NSNumber*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier]; + if (ret != nil && ret != o) { [ret retain]; } + } + return ret; + +} +BOOL +NSNumber_inst_IsLessThanOrEqualTo(void* o, void* object) { + BOOL ret; + @autoreleasepool { + ret = [(NSNumber*)o isLessThanOrEqualTo:object]; + } + return ret; + } void CBDelegateCentralManagerDidUpdateState(void*, void*); void CBDelegateCentralManagerDidConnectPeripheral(void*, void*, void*); +void CBDelegateCentralManagerDidDisconnectPeripheral(void*, void*, void*, void*); void CBDelegateCentralManagerDidDiscoverPeripheral(void*, void*, void*, void*, void*); void CBDelegatePeripheralDidDiscoverServices(void*, void*, void*); void CBDelegatePeripheralDidDiscoverCharacteristicsForService(void*, void*, void*, void*); @@ -29807,6 +29483,7 @@ void CBDelegatePeripheralDidUpdateValueForCharacteristic(void*, void*, void*, vo { } - (void)centralManagerDidUpdateState:(CBCentralManager* _Nonnull)central; - (void)centralManager:(CBCentralManager* _Nonnull)central didConnectPeripheral:(CBPeripheral* _Nonnull)peripheral; +- (void)centralManager:(CBCentralManager* _Nonnull)central didDisconnectPeripheral:(CBPeripheral* _Nonnull)peripheral error:(NSError* _Nullable)error; - (void)centralManager:(CBCentralManager* _Nonnull)central didDiscoverPeripheral:(CBPeripheral* _Nonnull)peripheral advertisementData:(NSDictionary * _Nonnull)advertisementData RSSI:(NSNumber* _Nonnull)RSSI; - (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverServices:(NSError* _Nullable)error; - (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverCharacteristicsForService:(CBService* _Nonnull)service error:(NSError* _Nullable)error; @@ -29828,6 +29505,12 @@ void CBDelegatePeripheralDidUpdateValueForCharacteristic(void*, void*, void*, vo } +- (void)centralManager:(CBCentralManager* _Nonnull)central didDisconnectPeripheral:(CBPeripheral* _Nonnull)peripheral error:(NSError* _Nullable)error +{ + CBDelegateCentralManagerDidDisconnectPeripheral(self, central, peripheral, error); +} + + - (void)centralManager:(CBCentralManager* _Nonnull)central didDiscoverPeripheral:(CBPeripheral* _Nonnull)peripheral advertisementData:(NSDictionary * _Nonnull)advertisementData RSSI:(NSNumber* _Nonnull)RSSI { CBDelegateCentralManagerDidDiscoverPeripheral(self, central, peripheral, advertisementData, RSSI); @@ -29872,12 +29555,6 @@ CBDelegate_inst_CentralManagerDidFailToConnectPeripheral(void* o, void* central, } } void -CBDelegate_inst_CentralManagerDidDisconnectPeripheral(void* o, void* central, void* peripheral, void* error) { - @autoreleasepool { - [(CBDelegate*)o centralManager:central didDisconnectPeripheral:peripheral error:error]; - } -} -void CBDelegate_inst_PeripheralDidUpdateName(void* o, void* peripheral) { @autoreleasepool { [(CBDelegate*)o peripheralDidUpdateName:peripheral]; @@ -29970,22 +29647,18 @@ type NSObject interface { Ptr() unsafe.Pointer } -type CBManager struct { Id } -func (o *CBManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBManager() *CBManager { - return (*CBManager)(unsafe.Pointer(o)) +type CBPeer struct { Id } +func (o *CBPeer) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBPeer() *CBPeer { + return (*CBPeer)(unsafe.Pointer(o)) } -type NSMethodSignature struct { Id } -func (o *NSMethodSignature) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSMethodSignature() *NSMethodSignature { - return (*NSMethodSignature)(unsafe.Pointer(o)) +type CBPeripheral struct { CBPeer } +func (o *CBPeripheral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBPeripheral() *CBPeripheral { + return (*CBPeripheral)(unsafe.Pointer(o)) } -type SEL *C.struct_objc_selector - -type NSInteger C.long - type _NSZone = C.struct__NSZone type NSString struct { Id } @@ -29996,10 +29669,22 @@ func (o *Id) NSString() *NSString { type Class *C.struct_objc_class -type NSArray struct { Id } -func (o *NSArray) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSArray() *NSArray { - return (*NSArray)(unsafe.Pointer(o)) +type BOOL C.uchar + +type SEL *C.struct_objc_selector + +type NSMethodSignature struct { Id } +func (o *NSMethodSignature) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSMethodSignature() *NSMethodSignature { + return (*NSMethodSignature)(unsafe.Pointer(o)) +} + +type NSUInteger C.ulong + +type NSInteger C.long + +type Protocol interface { + Ptr() unsafe.Pointer } type NSSet struct { Id } @@ -30008,36 +29693,10 @@ func (o *Id) NSSet() *NSSet { return (*NSSet)(unsafe.Pointer(o)) } -type BOOL C.uchar - -type Protocol interface { - Ptr() unsafe.Pointer -} - -type NSUInteger C.ulong - -type NSClassDescription struct { Id } -func (o *NSClassDescription) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSClassDescription() *NSClassDescription { - return (*NSClassDescription)(unsafe.Pointer(o)) -} - -type NSDictionary struct { Id } -func (o *NSDictionary) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSDictionary() *NSDictionary { - return (*NSDictionary)(unsafe.Pointer(o)) -} - -type NSError struct { Id } -func (o *NSError) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSError() *NSError { - return (*NSError)(unsafe.Pointer(o)) -} - -type NSMutableSet struct { NSSet } -func (o *NSMutableSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSMutableSet() *NSMutableSet { - return (*NSMutableSet)(unsafe.Pointer(o)) +type NSArray struct { Id } +func (o *NSArray) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSArray() *NSArray { + return (*NSArray)(unsafe.Pointer(o)) } type NSInvocation struct { Id } @@ -30046,14 +29705,6 @@ func (o *Id) NSInvocation() *NSInvocation { return (*NSInvocation)(unsafe.Pointer(o)) } -type NSKeyValueChange C.enum_NSKeyValueChange - -type NSIndexSet struct { Id } -func (o *NSIndexSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSIndexSet() *NSIndexSet { - return (*NSIndexSet)(unsafe.Pointer(o)) -} - type NSOrderedSet struct { Id } func (o *NSOrderedSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } func (o *Id) NSOrderedSet() *NSOrderedSet { @@ -30066,16 +29717,46 @@ func (o *Id) NSMutableOrderedSet() *NSMutableOrderedSet { return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } -type NSCoder struct { Id } -func (o *NSCoder) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSCoder() *NSCoder { - return (*NSCoder)(unsafe.Pointer(o)) +type CBPeripheralState C.enum_CBPeripheralState + +type NSData struct { Id } +func (o *NSData) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSData() *NSData { + return (*NSData)(unsafe.Pointer(o)) } -type NSKeyedArchiver struct { NSCoder } -func (o *NSKeyedArchiver) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSKeyedArchiver() *NSKeyedArchiver { - return (*NSKeyedArchiver)(unsafe.Pointer(o)) +type CBAttribute struct { Id } +func (o *CBAttribute) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBAttribute() *CBAttribute { + return (*CBAttribute)(unsafe.Pointer(o)) +} + +type CBDescriptor struct { CBAttribute } +func (o *CBDescriptor) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBDescriptor() *CBDescriptor { + return (*CBDescriptor)(unsafe.Pointer(o)) +} + +type CBCharacteristic struct { CBAttribute } +func (o *CBCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBCharacteristic() *CBCharacteristic { + return (*CBCharacteristic)(unsafe.Pointer(o)) +} + +type CBCharacteristicWriteType C.enum_CBCharacteristicWriteType + +type NSDictionary struct { Id } +func (o *NSDictionary) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSDictionary() *NSDictionary { + return (*NSDictionary)(unsafe.Pointer(o)) +} + +type FourCharCode C.UInt32 + +type CBService struct { CBAttribute } +func (o *CBService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBService() *CBService { + return (*CBService)(unsafe.Pointer(o)) } type NSScriptObjectSpecifier struct { Id } @@ -30090,9 +29771,45 @@ func (o *Id) NSMutableArray() *NSMutableArray { return (*NSMutableArray)(unsafe.Pointer(o)) } -type CBManagerState C.enum_CBManagerState +type NSUUID struct { Id } +func (o *NSUUID) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSUUID() *NSUUID { + return (*NSUUID)(unsafe.Pointer(o)) +} -type NSKeyValueSetMutationKind C.enum_NSKeyValueSetMutationKind +type NSKeyValueChange C.enum_NSKeyValueChange + +type NSIndexSet struct { Id } +func (o *NSIndexSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSIndexSet() *NSIndexSet { + return (*NSIndexSet)(unsafe.Pointer(o)) +} + +type NSKeyValueObservingOptions C.enum_NSKeyValueObservingOptions + +type NSError struct { Id } +func (o *NSError) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSError() *NSError { + return (*NSError)(unsafe.Pointer(o)) +} + +type NSClassDescription struct { Id } +func (o *NSClassDescription) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSClassDescription() *NSClassDescription { + return (*NSClassDescription)(unsafe.Pointer(o)) +} + +type NSMutableSet struct { NSSet } +func (o *NSMutableSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSMutableSet() *NSMutableSet { + return (*NSMutableSet)(unsafe.Pointer(o)) +} + +type NSCoder struct { Id } +func (o *NSCoder) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSCoder() *NSCoder { + return (*NSCoder)(unsafe.Pointer(o)) +} type NSTimeInterval C.double @@ -30102,14 +29819,12 @@ func (o *Id) NSThread() *NSThread { return (*NSThread)(unsafe.Pointer(o)) } -type FourCharCode C.UInt32 +type NSKeyValueSetMutationKind C.enum_NSKeyValueSetMutationKind -type NSKeyValueObservingOptions C.enum_NSKeyValueObservingOptions - -type CBAttribute struct { Id } -func (o *CBAttribute) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBAttribute() *CBAttribute { - return (*CBAttribute)(unsafe.Pointer(o)) +type NSKeyedArchiver struct { NSCoder } +func (o *NSKeyedArchiver) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSKeyedArchiver() *NSKeyedArchiver { + return (*NSKeyedArchiver)(unsafe.Pointer(o)) } type CBUUID struct { Id } @@ -30118,75 +29833,107 @@ func (o *Id) CBUUID() *CBUUID { return (*CBUUID)(unsafe.Pointer(o)) } -type NSUUID struct { Id } -func (o *NSUUID) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSUUID() *NSUUID { - return (*NSUUID)(unsafe.Pointer(o)) -} - -type NSData struct { Id } -func (o *NSData) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSData() *NSData { - return (*NSData)(unsafe.Pointer(o)) -} +type CBCharacteristicProperties C.enum_CBCharacteristicProperties type NSZone = C.struct__NSZone +type NSAutoreleasePool struct { Id } +func (o *NSAutoreleasePool) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSAutoreleasePool() *NSAutoreleasePool { + return (*NSAutoreleasePool)(unsafe.Pointer(o)) +} + +type CBManager struct { Id } +func (o *CBManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBManager() *CBManager { + return (*CBManager)(unsafe.Pointer(o)) +} + +type CBPeripheralManager struct { CBManager } +func (o *CBPeripheralManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBPeripheralManager() *CBPeripheralManager { + return (*CBPeripheralManager)(unsafe.Pointer(o)) +} + +type CBPeripheralManagerAuthorizationStatus C.enum_CBPeripheralManagerAuthorizationStatus + +type CBMutableCharacteristic struct { CBCharacteristic } +func (o *CBMutableCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBMutableCharacteristic() *CBMutableCharacteristic { + return (*CBMutableCharacteristic)(unsafe.Pointer(o)) +} + +type CBMutableService struct { CBService } +func (o *CBMutableService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBMutableService() *CBMutableService { + return (*CBMutableService)(unsafe.Pointer(o)) +} + +type Dispatch_queue_t = *Id + +type CBPeripheralManagerConnectionLatency C.enum_CBPeripheralManagerConnectionLatency + +type CBCentral struct { CBPeer } +func (o *CBCentral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBCentral() *CBCentral { + return (*CBCentral)(unsafe.Pointer(o)) +} + +type CBATTRequest struct { Id } +func (o *CBATTRequest) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) CBATTRequest() *CBATTRequest { + return (*CBATTRequest)(unsafe.Pointer(o)) +} + +type CBATTError C.enum_CBATTError + +type CBManagerState C.enum_CBManagerState + type NSURL struct { Id } func (o *NSURL) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } func (o *Id) NSURL() *NSURL { return (*NSURL)(unsafe.Pointer(o)) } -type NSStringEncoding C.NSUInteger - -type NSItemProviderRepresentationVisibility C.enum_NSItemProviderRepresentationVisibility - -type Char C.char - -type Unichar C.ushort - -type NSStringEncodingConversionOptions C.enum_NSStringEncodingConversionOptions +type NSEnumerator struct { Id } +func (o *NSEnumerator) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSEnumerator() *NSEnumerator { + return (*NSEnumerator)(unsafe.Pointer(o)) +} type NSRange = C.struct__NSRange -type NSRangePointer *C.NSRange - -type NSCharacterSet struct { Id } -func (o *NSCharacterSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSCharacterSet() *NSCharacterSet { - return (*NSCharacterSet)(unsafe.Pointer(o)) +type NSPredicate struct { Id } +func (o *NSPredicate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSPredicate() *NSPredicate { + return (*NSPredicate)(unsafe.Pointer(o)) } -type NSStringCompareOptions C.enum_NSStringCompareOptions +type NSFastEnumerationState = C.struct_NSFastEnumerationState -type NSLocale struct { Id } -func (o *NSLocale) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSLocale() *NSLocale { - return (*NSLocale)(unsafe.Pointer(o)) +type UnsignedChar C.uchar + +type OSType C.FourCharCode + +type NSValue struct { Id } +func (o *NSValue) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSValue() *NSValue { + return (*NSValue)(unsafe.Pointer(o)) } -type Double C.double - -type NSComparisonResult C.enum_NSComparisonResult - -type Float C.float - -type NSStringTransform = *NSString - -type Int C.int - -type NSLinguisticTagScheme = *NSString - -type NSLinguisticTaggerOptions C.enum_NSLinguisticTaggerOptions - -type NSOrthography struct { Id } -func (o *NSOrthography) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSOrthography() *NSOrthography { - return (*NSOrthography)(unsafe.Pointer(o)) +type NSNumber struct { NSValue } +func (o *NSNumber) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSNumber() *NSNumber { + return (*NSNumber)(unsafe.Pointer(o)) } -type LongLong C.longlong +type UnsignedLongLong C.ulonglong + +type NSDate struct { Id } +func (o *NSDate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSDate() *NSDate { + return (*NSDate)(unsafe.Pointer(o)) +} type NSDataReadingOptions C.enum_NSDataReadingOptions @@ -30204,144 +29951,74 @@ func (o *Id) CBCentralManager() *CBCentralManager { return (*CBCentralManager)(unsafe.Pointer(o)) } -type CBPeer struct { Id } -func (o *CBPeer) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBPeer() *CBPeer { - return (*CBPeer)(unsafe.Pointer(o)) +type Char C.char + +type NSStringEncoding C.NSUInteger + +type NSItemProviderRepresentationVisibility C.enum_NSItemProviderRepresentationVisibility + +type Unichar C.ushort + +type NSLocale struct { Id } +func (o *NSLocale) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSLocale() *NSLocale { + return (*NSLocale)(unsafe.Pointer(o)) } -type CBPeripheral struct { CBPeer } -func (o *CBPeripheral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBPeripheral() *CBPeripheral { - return (*CBPeripheral)(unsafe.Pointer(o)) +type NSStringCompareOptions C.enum_NSStringCompareOptions + +type NSLinguisticTagScheme = *NSString + +type NSLinguisticTaggerOptions C.enum_NSLinguisticTaggerOptions + +type NSOrthography struct { Id } +func (o *NSOrthography) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSOrthography() *NSOrthography { + return (*NSOrthography)(unsafe.Pointer(o)) } -type Dispatch_queue_t = *Id +type NSStringTransform = *NSString -type CBCentral struct { CBPeer } -func (o *CBCentral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBCentral() *CBCentral { - return (*CBCentral)(unsafe.Pointer(o)) +type NSCharacterSet struct { Id } +func (o *NSCharacterSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } +func (o *Id) NSCharacterSet() *NSCharacterSet { + return (*NSCharacterSet)(unsafe.Pointer(o)) } -type CBDescriptor struct { CBAttribute } -func (o *CBDescriptor) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBDescriptor() *CBDescriptor { - return (*CBDescriptor)(unsafe.Pointer(o)) -} +type LongLong C.longlong -type CBCharacteristic struct { CBAttribute } -func (o *CBCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBCharacteristic() *CBCharacteristic { - return (*CBCharacteristic)(unsafe.Pointer(o)) -} +type NSStringEncodingConversionOptions C.enum_NSStringEncodingConversionOptions -type NSEnumerator struct { Id } -func (o *NSEnumerator) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSEnumerator() *NSEnumerator { - return (*NSEnumerator)(unsafe.Pointer(o)) -} +type NSRangePointer *C.NSRange -type NSPredicate struct { Id } -func (o *NSPredicate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSPredicate() *NSPredicate { - return (*NSPredicate)(unsafe.Pointer(o)) -} +type NSComparisonResult C.enum_NSComparisonResult -type NSFastEnumerationState = C.struct_NSFastEnumerationState +type Double C.double -type NSValue struct { Id } -func (o *NSValue) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSValue() *NSValue { - return (*NSValue)(unsafe.Pointer(o)) -} +type Float C.float -type NSNumber struct { NSValue } -func (o *NSNumber) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSNumber() *NSNumber { - return (*NSNumber)(unsafe.Pointer(o)) -} - -type OSType C.FourCharCode - -type NSDate struct { Id } -func (o *NSDate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSDate() *NSDate { - return (*NSDate)(unsafe.Pointer(o)) -} - -type UnsignedLongLong C.ulonglong - -type CBPeripheralManager struct { CBManager } -func (o *CBPeripheralManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBPeripheralManager() *CBPeripheralManager { - return (*CBPeripheralManager)(unsafe.Pointer(o)) -} - -type CBPeripheralManagerAuthorizationStatus C.enum_CBPeripheralManagerAuthorizationStatus - -type CBService struct { CBAttribute } -func (o *CBService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBService() *CBService { - return (*CBService)(unsafe.Pointer(o)) -} - -type CBMutableService struct { CBService } -func (o *CBMutableService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBMutableService() *CBMutableService { - return (*CBMutableService)(unsafe.Pointer(o)) -} - -type CBMutableCharacteristic struct { CBCharacteristic } -func (o *CBMutableCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBMutableCharacteristic() *CBMutableCharacteristic { - return (*CBMutableCharacteristic)(unsafe.Pointer(o)) -} - -type CBATTRequest struct { Id } -func (o *CBATTRequest) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) CBATTRequest() *CBATTRequest { - return (*CBATTRequest)(unsafe.Pointer(o)) -} - -type CBATTError C.enum_CBATTError - -type CBPeripheralManagerConnectionLatency C.enum_CBPeripheralManagerConnectionLatency - -type CBCharacteristicProperties C.enum_CBCharacteristicProperties - -type NSAutoreleasePool struct { Id } -func (o *NSAutoreleasePool) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr } -func (o *Id) NSAutoreleasePool() *NSAutoreleasePool { - return (*NSAutoreleasePool)(unsafe.Pointer(o)) -} - -type UnsignedChar C.uchar - -type NSEdgeInsets = C.struct_NSEdgeInsets - -type NSSize C.CGSize - -type UnsignedShort C.ushort +type Int C.int type NSRect C.CGRect type Short C.short -type NSPoint C.CGPoint - type UnsignedInt C.uint type UnsignedLong C.ulong +type UnsignedShort C.ushort + +type NSPoint C.CGPoint + type Long C.long +type NSSize C.CGSize + +type NSEdgeInsets = C.struct_NSEdgeInsets + type NSDecimal = C.struct_NSDecimal -type CBCharacteristicWriteType C.enum_CBCharacteristicWriteType - -type CBPeripheralState C.enum_CBPeripheralState - type Dispatch_queue_attr_t = *Id type CBDelegate struct { Id } @@ -30355,6 +30032,18 @@ func (o *CBL2CAPChannel) Ptr() unsafe.Pointer { if o == nil { return nil }; retu func (o *Id) CBL2CAPChannel() *CBL2CAPChannel { return (*CBL2CAPChannel)(unsafe.Pointer(o)) } +const CBAttributePermissionsReadable NSUInteger= C.CBAttributePermissionsReadable +const CBAttributePermissionsWriteable NSUInteger= C.CBAttributePermissionsWriteable +const CBAttributePermissionsReadEncryptionRequired NSUInteger= C.CBAttributePermissionsReadEncryptionRequired +const CBAttributePermissionsWriteEncryptionRequired NSUInteger= C.CBAttributePermissionsWriteEncryptionRequired + +const CBManagerStateUnknown NSInteger= C.CBManagerStateUnknown +const CBManagerStateResetting NSInteger= C.CBManagerStateResetting +const CBManagerStateUnsupported NSInteger= C.CBManagerStateUnsupported +const CBManagerStateUnauthorized NSInteger= C.CBManagerStateUnauthorized +const CBManagerStatePoweredOff NSInteger= C.CBManagerStatePoweredOff +const CBManagerStatePoweredOn NSInteger= C.CBManagerStatePoweredOn + const CBErrorUnknown NSInteger= C.CBErrorUnknown const CBErrorInvalidParameters NSInteger= C.CBErrorInvalidParameters const CBErrorInvalidHandle NSInteger= C.CBErrorInvalidHandle @@ -30393,10 +30082,6 @@ const CBPeripheralManagerAuthorizationStatusRestricted NSInteger= C.CBPeripheral const CBPeripheralManagerAuthorizationStatusDenied NSInteger= C.CBPeripheralManagerAuthorizationStatusDenied const CBPeripheralManagerAuthorizationStatusAuthorized NSInteger= C.CBPeripheralManagerAuthorizationStatusAuthorized -const CBPeripheralManagerConnectionLatencyLow NSInteger= C.CBPeripheralManagerConnectionLatencyLow -const CBPeripheralManagerConnectionLatencyMedium NSInteger= C.CBPeripheralManagerConnectionLatencyMedium -const CBPeripheralManagerConnectionLatencyHigh NSInteger= C.CBPeripheralManagerConnectionLatencyHigh - const CBPeripheralStateDisconnected NSInteger= C.CBPeripheralStateDisconnected const CBPeripheralStateConnecting NSInteger= C.CBPeripheralStateConnecting const CBPeripheralStateConnected NSInteger= C.CBPeripheralStateConnected @@ -30416,23 +30101,27 @@ const CBCharacteristicPropertyExtendedProperties NSUInteger= C.CBCharacteristicP const CBCharacteristicPropertyNotifyEncryptionRequired NSUInteger= C.CBCharacteristicPropertyNotifyEncryptionRequired const CBCharacteristicPropertyIndicateEncryptionRequired NSUInteger= C.CBCharacteristicPropertyIndicateEncryptionRequired -const CBManagerStateUnknown NSInteger= C.CBManagerStateUnknown -const CBManagerStateResetting NSInteger= C.CBManagerStateResetting -const CBManagerStateUnsupported NSInteger= C.CBManagerStateUnsupported -const CBManagerStateUnauthorized NSInteger= C.CBManagerStateUnauthorized -const CBManagerStatePoweredOff NSInteger= C.CBManagerStatePoweredOff -const CBManagerStatePoweredOn NSInteger= C.CBManagerStatePoweredOn - -const CBAttributePermissionsReadable NSUInteger= C.CBAttributePermissionsReadable -const CBAttributePermissionsWriteable NSUInteger= C.CBAttributePermissionsWriteable -const CBAttributePermissionsReadEncryptionRequired NSUInteger= C.CBAttributePermissionsReadEncryptionRequired -const CBAttributePermissionsWriteEncryptionRequired NSUInteger= C.CBAttributePermissionsWriteEncryptionRequired +const CBPeripheralManagerConnectionLatencyLow NSInteger= C.CBPeripheralManagerConnectionLatencyLow +const CBPeripheralManagerConnectionLatencyMedium NSInteger= C.CBPeripheralManagerConnectionLatencyMedium +const CBPeripheralManagerConnectionLatencyHigh NSInteger= C.CBPeripheralManagerConnectionLatencyHigh func Selector(s string) SEL { return (SEL)(unsafe.Pointer(C.selectorFromString(C.CString(s)))) } +func Autoreleasepool(f func()) { + pool := NSAutoreleasePoolAlloc().Init() + f() + pool.Drain() +} + +func (e *NSEnumerator) ForIn(f func(*Id) bool) { + for o := e.NextObject(); o.Ptr() != nil; o = e.NextObject() { + if !f(o) { break } + } +} + func (o *NSString) String() string { utf8 := o.UTF8String() ret := utf8.String() @@ -30457,28193 +30146,25 @@ func (c *Char) Free() { C.free(unsafe.Pointer(c)) } -func (e *NSEnumerator) ForIn(f func(*Id) bool) { - for o := e.NextObject(); o.Ptr() != nil; o = e.NextObject() { - if !f(o) { break } - } -} - -func Autoreleasepool(f func()) { - pool := NSAutoreleasePoolAlloc().Init() - f() - pool.Drain() -} - -func CBManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBManagerNew() *CBManager { - ret := &CBManager{} - ret.ptr = unsafe.Pointer(C.CBManager_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBManager) { - o.Release() - }) - return ret -} - -func CBManagerSetVersion(aVersion NSInteger) { - C.CBManager_SetVersion((C.NSInteger)(aVersion)) -} - -func CBManagerAllocWithZone(zone *_NSZone) *CBManager { - ret := &CBManager{} - ret.ptr = unsafe.Pointer(C.CBManager_AllocWithZone(unsafe.Pointer(zone))) +func CBPeripheralAllocWithZone(zone *_NSZone) *CBPeripheral { + ret := &CBPeripheral{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_AllocWithZone(unsafe.Pointer(zone))) if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBManager) { - o.Release() - }) - return ret -} - -func CBManagerDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBManager_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBManagerAlloc() *CBManager { - ret := &CBManager{} - ret.ptr = unsafe.Pointer(C.CBManager_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBManager) { - o.Release() - }) - return ret -} - -func (o *CBManager) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBManager) { + runtime.SetFinalizer(ret, func(o *CBPeripheral) { o.Release() }) - runtime.KeepAlive(o) -} - -func CBManagerClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_ClassForKeyedUnarchiver())) - return ret -} - -func CBManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBManagerSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_Superclass())) - return ret -} - -func CBManagerClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBManager_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBManagerConformsToProtocol(protocol Protocol) bool { - ret := (C.CBManager_ConformsToProtocol(protocol.Ptr())) != 0 return ret } -func CBManagerDebugDescription() *NSString { +func CBPeripheralDescription() *NSString { ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBManager_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBManagerInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBManagerAccessInstanceVariablesDirectly() bool { - ret := (C.CBManager_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBManagerClass() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_Class())) - return ret -} - -func CBManagerResolveInstanceMethod(sel SEL) bool { - ret := (C.CBManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBManagerResolveClassMethod(sel SEL) bool { - ret := (C.CBManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBManagerIsSubclassOfClass(aClass Class) bool { - ret := (C.CBManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBManagerCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBManagerVersion() NSInteger { - ret := (NSInteger)(C.CBManager_Version()) - return ret -} - -func CBManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBManagerHash() NSUInteger { - ret := (NSUInteger)(C.CBManager_Hash()) - return ret -} - -func CBManagerLoad() { - C.CBManager_Load() -} - -func CBManagerMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_MutableCopyWithZone(unsafe.Pointer(zone))) + ret.ptr = unsafe.Pointer(C.CBPeripheral_Description()) if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func (o *CBManager) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IsGreaterThan(object NSObject) bool { - ret := (C.CBManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingContains(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ForwardInvocation(anInvocation *NSInvocation) { - C.CBManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) IsLessThan(object NSObject) bool { - ret := (C.CBManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IsLike(object *NSString) bool { - ret := (C.CBManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBManager) SetValueForKey(value NSObject, key *NSString) { - C.CBManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBManager_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IsNotEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) DoesContain(object NSObject) bool { - ret := (C.CBManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) DoesNotRecognizeSelector(aSelector SEL) { - C.CBManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBManager) IsEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) State() CBManagerState { - ret := (CBManagerState)(C.CBManager_inst_State(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) DidChangeValueForKey(key *NSString) { - C.CBManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) Dealloc() { - C.CBManager_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBManager_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBManager) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBManager) SetNilValueForKey(key *NSString) { - C.CBManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBManager) WillChangeValueForKey(key *NSString) { - C.CBManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func CBAttributeVersion() NSInteger { - ret := (NSInteger)(C.CBAttribute_Version()) - return ret -} - -func CBAttributeAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBAttribute_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBAttributeHash() NSUInteger { - ret := (NSUInteger)(C.CBAttribute_Hash()) - return ret -} - -func CBAttributeAlloc() *CBAttribute { - ret := &CBAttribute{} - ret.ptr = unsafe.Pointer(C.CBAttribute_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBAttribute) { - o.Release() - }) - return ret -} - -func (o *CBAttribute) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBAttribute) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBAttributeClass() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_Class())) - return ret -} - -func CBAttributeConformsToProtocol(protocol Protocol) bool { - ret := (C.CBAttribute_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBAttributeIsSubclassOfClass(aClass Class) bool { - ret := (C.CBAttribute_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBAttributeClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_ClassForKeyedUnarchiver())) - return ret -} - -func CBAttributeAccessInstanceVariablesDirectly() bool { - ret := (C.CBAttribute_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBAttributeSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_Superclass())) - return ret -} - -func CBAttributeKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBAttribute_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBAttributeSetVersion(aVersion NSInteger) { - C.CBAttribute_SetVersion((C.NSInteger)(aVersion)) -} - -func CBAttributeLoad() { - C.CBAttribute_Load() -} - -func CBAttributeMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBAttributeResolveClassMethod(sel SEL) bool { - ret := (C.CBAttribute_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBAttributeDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBAttribute_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBAttributeCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBAttributeDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBAttribute_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBAttributeNew() *CBAttribute { - ret := &CBAttribute{} - ret.ptr = unsafe.Pointer(C.CBAttribute_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBAttribute) { - o.Release() - }) - return ret -} - -func CBAttributeClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBAttributeAllocWithZone(zone *_NSZone) *CBAttribute { - ret := &CBAttribute{} - ret.ptr = unsafe.Pointer(C.CBAttribute_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBAttribute) { - o.Release() - }) - return ret -} - -func CBAttributeResolveInstanceMethod(sel SEL) bool { - ret := (C.CBAttribute_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBAttributeCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBAttribute_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBAttributeCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBAttributeCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBAttributeInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBAttribute_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBAttributeInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBAttribute_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func (o *CBAttribute) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) DidChangeValueForKey(key *NSString) { - C.CBAttribute_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBAttribute_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBAttribute_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBAttribute_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBAttribute_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBAttribute_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IsLike(object *NSString) bool { - ret := (C.CBAttribute_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBAttribute_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBAttribute_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBAttribute_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBAttribute_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBAttribute_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBAttribute_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBAttribute_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBAttribute_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBAttribute_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IsEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IsNotEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) SetNilValueForKey(key *NSString) { - C.CBAttribute_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBAttribute_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBAttribute_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IsLessThan(object NSObject) bool { - ret := (C.CBAttribute_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBAttribute_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) UUID() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_UUID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) WillChangeValueForKey(key *NSString) { - C.CBAttribute_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBAttribute_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBAttribute_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBAttribute_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBAttribute_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBAttribute_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBAttribute_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBAttribute_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBAttribute_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBAttribute_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) DoesNotRecognizeSelector(aSelector SEL) { - C.CBAttribute_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) IsGreaterThan(object NSObject) bool { - ret := (C.CBAttribute_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBAttribute_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ScriptingContains(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ForwardInvocation(anInvocation *NSInvocation) { - C.CBAttribute_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBAttribute_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBAttribute_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBAttribute_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBAttribute_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBAttribute_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) SetValueForKey(value NSObject, key *NSString) { - C.CBAttribute_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBAttribute_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBAttribute_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) Dealloc() { - C.CBAttribute_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) DoesContain(object NSObject) bool { - ret := (C.CBAttribute_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBAttribute) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBAttribute_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBAttribute_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBAttribute_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBAttribute) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBAttribute_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func CBUUIDAlloc() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func (o *CBUUID) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBUUIDHash() NSUInteger { - ret := (NSUInteger)(C.CBUUID_Hash()) - return ret -} - -func CBUUIDMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBUUIDSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_Superclass())) - return ret -} - -func CBUUIDClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBUUIDResolveInstanceMethod(sel SEL) bool { - ret := (C.CBUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBUUIDConformsToProtocol(protocol Protocol) bool { - ret := (C.CBUUID_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBUUIDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBUUID_DebugDescription()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func CBUUIDCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBUUIDWithNSUUID(theUUID *NSUUID) *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithNSUUID(theUUID.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func CBUUIDVersion() NSInteger { - ret := (NSInteger)(C.CBUUID_Version()) - return ret -} - -func CBUUIDAccessInstanceVariablesDirectly() bool { - ret := (C.CBUUID_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBUUIDAllocWithZone(zone *_NSZone) *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func CBUUIDClass() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_Class())) - return ret -} - -func CBUUIDResolveClassMethod(sel SEL) bool { - ret := (C.CBUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBUUIDInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBUUIDClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_ClassForKeyedUnarchiver())) - return ret -} - -func CBUUIDLoad() { - C.CBUUID_Load() -} - -func CBUUIDWithString(theString *NSString) *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithString(theString.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func CBUUIDWithGoString(theString string) *CBUUID { - theString_chr := CharWithGoString(theString) - defer theString_chr.Free() - ret := CBUUIDWithString(NSStringWithUTF8String(theString_chr)) - return ret -} - -func CBUUIDWithData(theData *NSData) *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithData(theData.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func CBUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBUUIDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBUUID_Description()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func CBUUIDNew() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - return ret -} - -func CBUUIDSetVersion(aVersion NSInteger) { - C.CBUUID_SetVersion((C.NSInteger)(aVersion)) -} - -func CBUUIDIsSubclassOfClass(aClass Class) bool { - ret := (C.CBUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func (o *CBUUID) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBUUID_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) Init() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingContains(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) SetNilValueForKey(key *NSString) { - C.CBUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) Dealloc() { - C.CBUUID_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ForwardInvocation(anInvocation *NSInvocation) { - C.CBUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBUUID_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) IsNotEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) WillChangeValueForKey(key *NSString) { - C.CBUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) Data() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_Data(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) IsGreaterThan(object NSObject) bool { - ret := (C.CBUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) DoesNotRecognizeSelector(aSelector SEL) { - C.CBUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) UUIDString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_UUIDString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) IsLessThan(object NSObject) bool { - ret := (C.CBUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) DidChangeValueForKey(key *NSString) { - C.CBUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) SetValueForKey(value NSObject, key *NSString) { - C.CBUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBUUID) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) IsLike(object *NSString) bool { - ret := (C.CBUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) DoesContain(object NSObject) bool { - ret := (C.CBUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) IsEqualTo(object NSObject) bool { - ret := (C.CBUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func NSStringInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSString_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSStringObjectWithItemProviderDataTypeIdentifier(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice2[i] = (*outError)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifier(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice2[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - return ret -} - -func NSStringObjectWithItemProviderDataTypeIdentifierError(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice2[i] = (*outError)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifierError(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice2[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - return ret -} - -func NSStringWritableTypeIdentifiersForItemProvider() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_WritableTypeIdentifiersForItemProvider()) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncoding(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncoding(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncodingError(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncodingError(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringAvailableStringEncodings() *NSStringEncoding { - ret := (*NSStringEncoding)(unsafe.Pointer(C.NSString_AvailableStringEncodings())) - return ret -} - -func NSStringEncodingForDataEncodingOptions(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding { - - goSlice2 := make([]unsafe.Pointer,cap(*string)) - for i := 0; i < len(*string); i++ { - goSlice2[i] = (*string)[i].Ptr() - } - ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptions(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion))) - (*string) = (*string)[:cap(*string)] - for i := 0; i < len(*string); i++ { - if goSlice2[i] == nil { - (*string) = (*string)[:i] - break - } - if (*string)[i] == nil { - (*string)[i] = &NSString{} - runtime.SetFinalizer((*string)[i], func(o *NSString) { - o.Release() - }) - } - (*string)[i].ptr = goSlice2[i] - } - return ret -} - -func NSStringEncodingForDataEncodingOptionsConvertedString(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding { - - goSlice2 := make([]unsafe.Pointer,cap(*string)) - for i := 0; i < len(*string); i++ { - goSlice2[i] = (*string)[i].Ptr() - } - ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptionsConvertedString(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion))) - (*string) = (*string)[:cap(*string)] - for i := 0; i < len(*string); i++ { - if goSlice2[i] == nil { - (*string) = (*string)[:i] - break - } - if (*string)[i] == nil { - (*string)[i] = &NSString{} - runtime.SetFinalizer((*string)[i], func(o *NSString) { - o.Release() - }) - } - (*string)[i].ptr = goSlice2[i] - } - return ret -} - -func NSStringResolveClassMethod(sel SEL) bool { - ret := (C.NSString_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSStringClass() Class { - ret := (Class)(unsafe.Pointer(C.NSString_Class())) - return ret -} - -func NSStringResolveInstanceMethod(sel SEL) bool { - ret := (C.NSString_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSStringLoad() { - C.NSString_Load() -} - -func NSStringItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility { - ret := (NSItemProviderRepresentationVisibility)(C.NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier.Ptr())) - return ret -} - -func NSStringString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_String()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithString(string *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithString(string.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithGoString(string string) *NSString { - string_chr := CharWithGoString(string) - defer string_chr.Free() - ret := NSStringWithString(NSStringWithUTF8String(string_chr)) - return ret -} - -func NSStringSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSString_Superclass())) - return ret -} - -func NSStringKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSString_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringWithCStringEncoding(cString *Char, enc NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithCStringEncoding(unsafe.Pointer(cString), (C.NSStringEncoding)(enc))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringVersion() NSInteger { - ret := (NSInteger)(C.NSString_Version()) - return ret -} - -func NSStringNew() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringAccessInstanceVariablesDirectly() bool { - ret := (C.NSString_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSStringCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSStringDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringWithUTF8String(nullTerminatedCString *Char) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithUTF8String(unsafe.Pointer(nullTerminatedCString))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSString_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringAllocWithZone(zone *_NSZone) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringConformsToProtocol(protocol Protocol) bool { - ret := (C.NSString_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSStringReadableTypeIdentifiersForItemProvider() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_ReadableTypeIdentifiersForItemProvider()) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSString_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSStringDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSString_ClassForKeyedUnarchiver())) - return ret -} - -func NSStringSetVersion(aVersion NSInteger) { - C.NSString_SetVersion((C.NSInteger)(aVersion)) -} - -func NSStringHash() NSUInteger { - ret := (NSUInteger)(C.NSString_Hash()) - return ret -} - -func NSStringAlloc() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func (o *NSString) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSStringCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSString_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSStringCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSString_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSStringCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSString_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSStringLocalizedNameOfStringEncoding(encoding NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_LocalizedNameOfStringEncoding((C.NSStringEncoding)(encoding))) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringWithFormat(format *NSString, objects ...NSObject) *NSString { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithFormat(format.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithCharactersLength(characters *Unichar, length NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithCharactersLength(unsafe.Pointer(characters), (C.NSUInteger)(length))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringPathWithComponents(components *NSArray) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_PathWithComponents(components.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringIsSubclassOfClass(aClass Class) bool { - ret := (C.NSString_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSStringMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSStringSupportsSecureCoding() bool { - ret := (C.NSString_SupportsSecureCoding()) != 0 - return ret -} - -func NSStringWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncoding(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncoding(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncodingError(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncodingError(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSStringLocalizedStringWithFormat(format *NSString, objects ...NSObject) *NSString { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_LocalizedStringWithFormat(format.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { return ret } - return ret -} - -func NSStringDefaultCStringEncoding() NSStringEncoding { - ret := (NSStringEncoding)(C.NSString_DefaultCStringEncoding()) - return ret -} - -func NSStringClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func (o *NSString) GetBytesMaxLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool { - ret := (C.NSString_inst_GetBytesMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetBytesMaxLengthUsedLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool { - ret := (C.NSString_inst_GetBytesMaxLengthUsedLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SmallestEncoding() NSStringEncoding { - ret := (NSStringEncoding)(C.NSString_inst_SmallestEncoding(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSString_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { - - goSlice4 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice4[i] = (*error)[i].Ptr() - } - ret := (C.NSString_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice4[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice4[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WriteToFileAtomicallyEncoding(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { - - goSlice4 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice4[i] = (*error)[i].Ptr() - } - ret := (C.NSString_inst_WriteToFileAtomicallyEncoding(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice4[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice4[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithCStringEncoding(nullTerminatedCString *Char, encoding NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCStringEncoding(o.Ptr(), unsafe.Pointer(nullTerminatedCString), (C.NSStringEncoding)(encoding))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByTrimmingCharactersInSet(set *NSCharacterSet) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByTrimmingCharactersInSet(o.Ptr(), set.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByFoldingWithOptionsLocale(options NSStringCompareOptions, locale *NSLocale) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByFoldingWithOptionsLocale(o.Ptr(), (C.NSStringCompareOptions)(options), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSString_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSString_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) FileSystemRepresentation() *Char { - ret := (*Char)(unsafe.Pointer(C.NSString_inst_FileSystemRepresentation(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LowercaseString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsLike(object *NSString) bool { - ret := (C.NSString_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncoding(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncoding(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncodingError(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncodingError(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) Init() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) VariantFittingPresentationWidth(width NSInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_VariantFittingPresentationWidth(o.Ptr(), (C.NSInteger)(width))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CStringUsingEncoding(encoding NSStringEncoding) *Char { - ret := (*Char)(unsafe.Pointer(C.NSString_inst_CStringUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding)))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ComponentsSeparatedByCharactersInSet(separator *NSCharacterSet) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByCharactersInSet(o.Ptr(), separator.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSString_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSString) StringByPaddingToLengthWithString(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithString(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByPaddingToLengthWithStringStartingAtIndex(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithStringStartingAtIndex(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetCharacters(buffer *Unichar) { - C.NSString_inst_GetCharacters(o.Ptr(), unsafe.Pointer(buffer)) - runtime.KeepAlive(o) -} - -func (o *NSString) GetCharactersRange(buffer *Unichar, range_ NSRange) { - C.NSString_inst_GetCharactersRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSString) IsGreaterThan(object NSObject) bool { - ret := (C.NSString_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAddingPercentEncodingWithAllowedCharacters(allowedCharacters *NSCharacterSet) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(o.Ptr(), allowedCharacters.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MaximumLengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger { - ret := (NSUInteger)(C.NSString_inst_MaximumLengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsAbsolutePath() bool { - ret := (C.NSString_inst_IsAbsolutePath(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingContains(object NSObject) bool { - ret := (C.NSString_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) HasSuffix(str *NSString) bool { - ret := (C.NSString_inst_HasSuffix(o.Ptr(), str.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSString_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) StringByDeletingLastPathComponent() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingLastPathComponent(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) Length() NSUInteger { - ret := (NSUInteger)(C.NSString_inst_Length(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ParagraphRangeForRange(range_ NSRange) NSRange { - ret := (NSRange)(C.NSString_inst_ParagraphRangeForRange(o.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DecomposedStringWithCanonicalMapping() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCanonicalMapping(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByResolvingSymlinksInPath() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByResolvingSymlinksInPath(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSString_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfCharacterFromSet(searchSet *NSCharacterSet) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSet(o.Ptr(), searchSet.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfCharacterFromSetOptions(searchSet *NSCharacterSet, mask NSStringCompareOptions) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptions(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfCharacterFromSetOptionsRange(searchSet *NSCharacterSet, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptionsRange(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) UTF8String() *Char { - ret := (*Char)(unsafe.Pointer(C.NSString_inst_UTF8String(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithUTF8String(nullTerminatedCString *Char) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithUTF8String(o.Ptr(), unsafe.Pointer(nullTerminatedCString))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetParagraphStartEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { - C.NSString_inst_GetParagraphStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSString) GetParagraphStartEndContentsEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { - C.NSString_inst_GetParagraphStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSString) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSString_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSString) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSString_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSString) StringByStandardizingPath() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByStandardizingPath(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedStandardContainsString(str *NSString) bool { - ret := (C.NSString_inst_LocalizedStandardContainsString(o.Ptr(), str.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DoubleValue() Double { - ret := (Double)(C.NSString_inst_DoubleValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAppendingString(aString *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingString(o.Ptr(), aString.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSString_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WillChangeValueForKey(key *NSString) { - C.NSString_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSString_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ComponentsSeparatedByString(separator *NSString) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByString(o.Ptr(), separator.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSString_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithBytesNoCopyLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithBytesNoCopyLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLengthEncoding(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByExpandingTildeInPath() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByExpandingTildeInPath(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSString_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) DoesContain(object NSObject) bool { - ret := (C.NSString_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithBytesLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithBytesLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLengthEncoding(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSString_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSString_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSString_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SubstringWithRange(range_ NSRange) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringWithRange(o.Ptr(), (C.NSRange)(range_))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithFormat(format *NSString, objects ...NSObject) *NSString { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithFormatLocale(format *NSString, locale NSObject, objects ...NSObject) *NSString { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatLocale(o.Ptr(), format.Ptr(), locale.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WriteToURLAtomically(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { - - goSlice4 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice4[i] = (*error)[i].Ptr() - } - ret := (C.NSString_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice4[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice4[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WriteToURLAtomicallyEncoding(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { - - goSlice4 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice4[i] = (*error)[i].Ptr() - } - ret := (C.NSString_inst_WriteToURLAtomicallyEncoding(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice4[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice4[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PrecomposedStringWithCompatibilityMapping() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCompatibilityMapping(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetCStringMaxLength(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool { - ret := (C.NSString_inst_GetCStringMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetCStringMaxLengthEncoding(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool { - ret := (C.NSString_inst_GetCStringMaxLengthEncoding(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DidChangeValueForKey(key *NSString) { - C.NSString_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSString_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSString_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableCopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) UppercaseStringWithLocale(locale *NSLocale) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseStringWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsNotEqualTo(object NSObject) bool { - ret := (C.NSString_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringsByAppendingPaths(paths *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringsByAppendingPaths(o.Ptr(), paths.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PropertyList() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyList(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSString_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSString_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) LocalizedStandardCompare(string *NSString) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_LocalizedStandardCompare(o.Ptr(), string.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSString_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSString) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSString_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSString) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsEqualToString(aString *NSString) bool { - ret := (C.NSString_inst_IsEqualToString(o.Ptr(), aString.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithCharactersNoCopyLength(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithCharactersNoCopyLengthFreeWhenDone(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) FloatValue() Float { - ret := (Float)(C.NSString_inst_FloatValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) Hash() NSUInteger { - ret := (NSUInteger)(C.NSString_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PathComponents() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PathComponents(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SetNilValueForKey(key *NSString) { - C.NSString_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) Dealloc() { - C.NSString_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSString_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSString_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) CaseInsensitiveCompare(string *NSString) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_CaseInsensitiveCompare(o.Ptr(), string.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CanBeConvertedToEncoding(encoding NSStringEncoding) bool { - ret := (C.NSString_inst_CanBeConvertedToEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CapitalizedString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) FastestEncoding() NSStringEncoding { - ret := (NSStringEncoding)(C.NSString_inst_FastestEncoding(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSString_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility { - ret := (NSItemProviderRepresentationVisibility)(C.NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(o.Ptr(), typeIdentifier.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PrecomposedStringWithCanonicalMapping() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCanonicalMapping(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAppendingPathComponent(str *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathComponent(o.Ptr(), str.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByApplyingTransformReverse(transform NSStringTransform, reverse BOOL) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByApplyingTransformReverse(o.Ptr(), transform.Ptr(), (C.BOOL)(reverse))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSString_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSString_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSString) GetFileSystemRepresentationMaxLength(cname *Char, max NSUInteger) bool { - ret := (C.NSString_inst_GetFileSystemRepresentationMaxLength(o.Ptr(), unsafe.Pointer(cname), (C.NSUInteger)(max))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ForwardInvocation(anInvocation *NSInvocation) { - C.NSString_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSString_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSString_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSString_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSString_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) DataUsingEncoding(encoding NSStringEncoding) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DataUsingEncodingAllowLossyConversion(encoding NSStringEncoding, lossy BOOL) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncodingAllowLossyConversion(o.Ptr(), (C.NSStringEncoding)(encoding), (C.BOOL)(lossy))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedCompare(string *NSString) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_LocalizedCompare(o.Ptr(), string.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IntValue() Int { - ret := (Int)(C.NSString_inst_IntValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithCoder(aDecoder *NSCoder) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSString_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSString_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSString) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAbbreviatingWithTildeInPath() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAbbreviatingWithTildeInPath(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DecomposedStringWithCompatibilityMapping() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCompatibilityMapping(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IntegerValue() NSInteger { - ret := (NSInteger)(C.NSString_inst_IntegerValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DoesNotRecognizeSelector(aSelector SEL) { - C.NSString_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSString) LinguisticTagsInRangeScheme(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray { - - goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges)) - for i := 0; i < len(*tokenRanges); i++ { - goSlice5[i] = (*tokenRanges)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeScheme(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0])))) - (*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)] - for i := 0; i < len(*tokenRanges); i++ { - if goSlice5[i] == nil { - (*tokenRanges) = (*tokenRanges)[:i] - break - } - if (*tokenRanges)[i] == nil { - (*tokenRanges)[i] = &NSArray{} - runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) { - o.Release() - }) - } - (*tokenRanges)[i].ptr = goSlice5[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LinguisticTagsInRangeSchemeOptions(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray { - - goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges)) - for i := 0; i < len(*tokenRanges); i++ { - goSlice5[i] = (*tokenRanges)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeSchemeOptions(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0])))) - (*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)] - for i := 0; i < len(*tokenRanges); i++ { - if goSlice5[i] == nil { - (*tokenRanges) = (*tokenRanges)[:i] - break - } - if (*tokenRanges)[i] == nil { - (*tokenRanges)[i] = &NSArray{} - runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) { - o.Release() - }) - } - (*tokenRanges)[i].ptr = goSlice5[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfComposedCharacterSequenceAtIndex(index NSUInteger) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequenceAtIndex(o.Ptr(), (C.NSUInteger)(index))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LowercaseStringWithLocale(locale *NSLocale) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseStringWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedCapitalizedString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedCapitalizedString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByDeletingPathExtension() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingPathExtension(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) HasPrefix(str *NSString) bool { - ret := (C.NSString_inst_HasPrefix(o.Ptr(), str.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PropertyListFromStringsFileFormat() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyListFromStringsFileFormat(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) GetLineStartEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { - C.NSString_inst_GetLineStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSString) GetLineStartEndContentsEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { - C.NSString_inst_GetLineStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSString) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedUppercaseString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedUppercaseString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByReplacingOccurrencesOfStringWithString(target *NSString, replacement *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithString(o.Ptr(), target.Ptr(), replacement.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptions(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptionsRange(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAppendingPathExtension(str *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathExtension(o.Ptr(), str.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SubstringToIndex(to NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringToIndex(o.Ptr(), (C.NSUInteger)(to))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsLessThan(object NSObject) bool { - ret := (C.NSString_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSString_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSString_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSString_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSString_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSString_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSString_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSString_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSString_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSString_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSString_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedLowercaseString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedLowercaseString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedStandardRangeOfString(str *NSString) NSRange { - ret := (NSRange)(C.NSString_inst_LocalizedStandardRangeOfString(o.Ptr(), str.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfComposedCharacterSequencesForRange(range_ NSRange) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequencesForRange(o.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CapitalizedStringWithLocale(locale *NSLocale) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedStringWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) Compare(string *NSString) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_Compare(o.Ptr(), string.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CompareOptions(string *NSString, mask NSStringCompareOptions) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_CompareOptions(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CompareOptionsRange(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRange(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CompareOptionsRangeLocale(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange, locale NSObject) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRangeLocale(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare), locale.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedCaseInsensitiveContainsString(str *NSString) bool { - ret := (C.NSString_inst_LocalizedCaseInsensitiveContainsString(o.Ptr(), str.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByRemovingPercentEncoding() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByRemovingPercentEncoding(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) BoolValue() bool { - ret := (C.NSString_inst_BoolValue(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ContainsString(str *NSString) bool { - ret := (C.NSString_inst_ContainsString(o.Ptr(), str.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SetValueForKey(value NSObject, key *NSString) { - C.NSString_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSString_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSString_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSString_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger { - ret := (NSUInteger)(C.NSString_inst_LengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CharacterAtIndex(index NSUInteger) Unichar { - ret := (Unichar)(C.NSString_inst_CharacterAtIndex(o.Ptr(), (C.NSUInteger)(index))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByAppendingFormat(format *NSString, objects ...NSObject) *NSString { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithDataEncoding(data *NSData, encoding NSStringEncoding) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithDataEncoding(o.Ptr(), data.Ptr(), (C.NSStringEncoding)(encoding))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSString_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) WritableTypeIdentifiersForItemProvider() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSString_inst_WritableTypeIdentifiersForItemProvider(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CompletePathIntoStringCaseSensitive(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger { - - goSlice1 := make([]unsafe.Pointer,cap(*outputName)) - for i := 0; i < len(*outputName); i++ { - goSlice1[i] = (*outputName)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outputArray)) - for i := 0; i < len(*outputArray); i++ { - goSlice3[i] = (*outputArray)[i].Ptr() - } - ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitive(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr())) - (*outputName) = (*outputName)[:cap(*outputName)] - for i := 0; i < len(*outputName); i++ { - if goSlice1[i] == nil { - (*outputName) = (*outputName)[:i] - break - } - if (*outputName)[i] == nil { - (*outputName)[i] = &NSString{} - runtime.SetFinalizer((*outputName)[i], func(o *NSString) { - o.Release() - }) - } - (*outputName)[i].ptr = goSlice1[i] - } - (*outputArray) = (*outputArray)[:cap(*outputArray)] - for i := 0; i < len(*outputArray); i++ { - if goSlice3[i] == nil { - (*outputArray) = (*outputArray)[:i] - break - } - if (*outputArray)[i] == nil { - (*outputArray)[i] = &NSArray{} - runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) { - o.Release() - }) - } - (*outputArray)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CompletePathIntoStringCaseSensitiveMatchesIntoArray(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger { - - goSlice1 := make([]unsafe.Pointer,cap(*outputName)) - for i := 0; i < len(*outputName); i++ { - goSlice1[i] = (*outputName)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outputArray)) - for i := 0; i < len(*outputArray); i++ { - goSlice3[i] = (*outputArray)[i].Ptr() - } - ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr())) - (*outputName) = (*outputName)[:cap(*outputName)] - for i := 0; i < len(*outputName); i++ { - if goSlice1[i] == nil { - (*outputName) = (*outputName)[:i] - break - } - if (*outputName)[i] == nil { - (*outputName)[i] = &NSString{} - runtime.SetFinalizer((*outputName)[i], func(o *NSString) { - o.Release() - }) - } - (*outputName)[i].ptr = goSlice1[i] - } - (*outputArray) = (*outputArray)[:cap(*outputArray)] - for i := 0; i < len(*outputArray); i++ { - if goSlice3[i] == nil { - (*outputArray) = (*outputArray)[:i] - break - } - if (*outputArray)[i] == nil { - (*outputArray)[i] = &NSArray{} - runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) { - o.Release() - }) - } - (*outputArray)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LineRangeForRange(range_ NSRange) NSRange { - ret := (NSRange)(C.NSString_inst_LineRangeForRange(o.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) SubstringFromIndex(from NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringFromIndex(o.Ptr(), (C.NSUInteger)(from))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) UppercaseString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LastPathComponent() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_LastPathComponent(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LocalizedCaseInsensitiveCompare(string *NSString) NSComparisonResult { - ret := (NSComparisonResult)(C.NSString_inst_LocalizedCaseInsensitiveCompare(o.Ptr(), string.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) PathExtension() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_PathExtension(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CommonPrefixWithStringOptions(str *NSString, mask NSStringCompareOptions) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_CommonPrefixWithStringOptions(o.Ptr(), str.Ptr(), (C.NSStringCompareOptions)(mask))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) CommonPrefixWithStringOGoString(str string, mask NSStringCompareOptions) *NSString { - str_chr := CharWithGoString(str) - defer str_chr.Free() - ret := o.CommonPrefixWithStringOptions(NSStringWithUTF8String(str_chr), mask) - return ret -} - -func (o *NSString) RangeOfString(searchString *NSString) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfString(o.Ptr(), searchString.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfStringOptions(searchString *NSString, mask NSStringCompareOptions) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfStringOptions(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfStringOptionsRange(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRange(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) RangeOfStringOptionsRangeLocale(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange, locale *NSLocale) NSRange { - ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRangeLocale(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch), locale.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSString_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSString_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSString_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSString) InitWithCharactersLength(characters *Unichar, length NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) StringByReplacingCharactersInRangeWithString(range_ NSRange, replacement *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingCharactersInRangeWithString(o.Ptr(), (C.NSRange)(range_), replacement.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncoding(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncoding(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncodingError(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { - - goSlice3 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice3[i] = (*error)[i].Ptr() - } - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncodingError(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice3[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) LongLongValue() LongLong { - ret := (LongLong)(C.NSString_inst_LongLongValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithString(aString *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithString(o.Ptr(), aString.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) InitWithGoString(aString string) *NSString { - aString_chr := CharWithGoString(aString) - defer aString_chr.Free() - ret := o.InitWithString(NSStringWithUTF8String(aString_chr)) - return ret -} - -func (o *NSString) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSString_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSString) IsEqualTo(object NSObject) bool { - ret := (C.NSString_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func NSDataSetVersion(aVersion NSInteger) { - C.NSData_SetVersion((C.NSInteger)(aVersion)) -} - -func NSDataClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSData_ClassForKeyedUnarchiver())) - return ret -} - -func NSDataMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSDataCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSData_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSDataCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSData_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSDataCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSData_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSDataData() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_Data()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSData_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDataIsSubclassOfClass(aClass Class) bool { - ret := (C.NSData_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSDataAlloc() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func (o *NSData) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSDataInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSData_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSDataClass() Class { - ret := (Class)(unsafe.Pointer(C.NSData_Class())) - return ret -} - -func NSDataWithData(data *NSData) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithData(data.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSDataVersion() NSInteger { - ret := (NSInteger)(C.NSData_Version()) - return ret -} - -func NSDataSupportsSecureCoding() bool { - ret := (C.NSData_SupportsSecureCoding()) != 0 - return ret -} - -func NSDataAccessInstanceVariablesDirectly() bool { - ret := (C.NSData_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSDataAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSData_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSDataKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSData_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSDataInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSData_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSDataHash() NSUInteger { - ret := (NSUInteger)(C.NSData_Hash()) - return ret -} - -func NSDataWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesLength(unsafe.Pointer(bytes), (C.NSUInteger)(length))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLength(unsafe.Pointer(bytes), (C.NSUInteger)(length))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLengthFreeWhenDone(unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataResolveInstanceMethod(sel SEL) bool { - ret := (C.NSData_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSDataResolveClassMethod(sel SEL) bool { - ret := (C.NSData_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSDataDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDataWithContentsOfFile(path *NSString) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFile(path.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice2[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptions(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice2[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice2[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptionsError(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice2[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataAllocWithZone(zone *_NSZone) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithContentsOfURL(url *NSURL) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURL(url.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice2[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptions(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice2[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice2[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptionsError(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice2[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataLoad() { - C.NSData_Load() -} - -func NSDataConformsToProtocol(protocol Protocol) bool { - ret := (C.NSData_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSDataDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDataNew() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - return ret -} - -func NSDataSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSData_Superclass())) - return ret -} - -func (o *NSData) InitWithBase64EncodedDataOptions(base64Data *NSData, options NSDataBase64DecodingOptions) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedDataOptions(o.Ptr(), base64Data.Ptr(), (C.NSDataBase64DecodingOptions)(options))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { - ret := (C.NSData_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToURLOptions(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := (C.NSData_inst_WriteToURLOptions(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToURLOptionsError(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := (C.NSData_inst_WriteToURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSData_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSData_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSData_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSData_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSData_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSData_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfURL(url *NSURL) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptions(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfFile(path *NSString) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptions(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsNotEqualTo(object NSObject) bool { - ret := (C.NSData_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSData_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSData_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSData_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSData_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSData_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSData_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSData_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsLike(object *NSString) bool { - ret := (C.NSData_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSData_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSData) InitWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSData_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) DoesNotRecognizeSelector(aSelector SEL) { - C.NSData_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSData) SetValueForKey(value NSObject, key *NSString) { - C.NSData_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSData_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSData_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSData_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSData_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSData_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSData_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) Length() NSUInteger { - ret := (NSUInteger)(C.NSData_inst_Length(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ForwardInvocation(anInvocation *NSInvocation) { - C.NSData_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSData_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSData) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSData_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSData) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) GetBytesLength(buffer unsafe.Pointer, length NSUInteger) { - C.NSData_inst_GetBytesLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(length)) - runtime.KeepAlive(o) -} - -func (o *NSData) GetBytesRange(buffer unsafe.Pointer, range_ NSRange) { - C.NSData_inst_GetBytesRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSData) InitWithData(data *NSData) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithData(o.Ptr(), data.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsLessThan(object NSObject) bool { - ret := (C.NSData_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsGreaterThan(object NSObject) bool { - ret := (C.NSData_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSData_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSData_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSData_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSData_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSData_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) SubdataWithRange(range_ NSRange) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_SubdataWithRange(o.Ptr(), (C.NSRange)(range_))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSData_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSData_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WillChangeValueForKey(key *NSString) { - C.NSData_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSData_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSData_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) MutableCopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSData_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSData) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSData_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSData) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) SetNilValueForKey(key *NSString) { - C.NSData_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) Dealloc() { - C.NSData_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) Base64EncodedStringWithOptions(options NSDataBase64EncodingOptions) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedStringWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSData_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSData_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSData) DoesContain(object NSObject) bool { - ret := (C.NSData_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) Base64EncodedDataWithOptions(options NSDataBase64EncodingOptions) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedDataWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSData_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSData_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingContains(object NSObject) bool { - ret := (C.NSData_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) Init() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) Bytes() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_Bytes(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSData_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSData_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSData_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { - ret := (C.NSData_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToFileOptions(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := (C.NSData_inst_WriteToFileOptions(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) WriteToFileOptionsError(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { - - goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) - for i := 0; i < len(*errorPtr); i++ { - goSlice3[i] = (*errorPtr)[i].Ptr() - } - ret := (C.NSData_inst_WriteToFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] - for i := 0; i < len(*errorPtr); i++ { - if goSlice3[i] == nil { - (*errorPtr) = (*errorPtr)[:i] - break - } - if (*errorPtr)[i] == nil { - (*errorPtr)[i] = &NSError{} - runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { - o.Release() - }) - } - (*errorPtr)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSData_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSData_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) IsEqualToData(other *NSData) bool { - ret := (C.NSData_inst_IsEqualToData(o.Ptr(), other.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSData_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSData_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSData_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) DidChangeValueForKey(key *NSString) { - C.NSData_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSData_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSData_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSData) IsEqualTo(object NSObject) bool { - ret := (C.NSData_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) RangeOfDataOptions(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange { - ret := (NSRange)(C.NSData_inst_RangeOfDataOptions(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) RangeOfDataOptionsRange(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange { - ret := (NSRange)(C.NSData_inst_RangeOfDataOptionsRange(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSData_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSData) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSData) InitWithBase64EncodedStringOptions(base64String *NSString, options NSDataBase64DecodingOptions) *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedStringOptions(o.Ptr(), base64String.Ptr(), (C.NSDataBase64DecodingOptions)(options))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func CBCentralManagerHash() NSUInteger { - ret := (NSUInteger)(C.CBCentralManager_Hash()) - return ret -} - -func CBCentralManagerMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCentralManagerClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_ClassForKeyedUnarchiver())) - return ret -} - -func CBCentralManagerSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_Superclass())) - return ret -} - -func CBCentralManagerClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralManagerAccessInstanceVariablesDirectly() bool { - ret := (C.CBCentralManager_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBCentralManagerResolveClassMethod(sel SEL) bool { - ret := (C.CBCentralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCentralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralManagerConformsToProtocol(protocol Protocol) bool { - ret := (C.CBCentralManager_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBCentralManagerInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBCentralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBCentralManagerClass() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_Class())) - return ret -} - -func CBCentralManagerVersion() NSInteger { - ret := (NSInteger)(C.CBCentralManager_Version()) - return ret -} - -func CBCentralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBCentralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBCentralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralManagerSetVersion(aVersion NSInteger) { - C.CBCentralManager_SetVersion((C.NSInteger)(aVersion)) -} - -func CBCentralManagerAlloc() *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - return ret -} - -func (o *CBCentralManager) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBCentralManager) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBCentralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBCentralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCentralManagerDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralManagerCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCentralManagerLoad() { - C.CBCentralManager_Load() -} - -func CBCentralManagerNew() *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - return ret -} - -func CBCentralManagerAllocWithZone(zone *_NSZone) *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - return ret -} - -func CBCentralManagerDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralManagerResolveInstanceMethod(sel SEL) bool { - ret := (C.CBCentralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCentralManagerIsSubclassOfClass(aClass Class) bool { - ret := (C.CBCentralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func (o *CBCentralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) DidChangeValueForKey(key *NSString) { - C.CBCentralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCentralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) DoesNotRecognizeSelector(aSelector SEL) { - C.CBCentralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBCentralManager_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingContains(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBCentralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) IsNotEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetNilValueForKey(key *NSString) { - C.CBCentralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) Init() *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsLessThan(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) CancelPeripheralConnection(peripheral *CBPeripheral) { - C.CBCentralManager_inst_CancelPeripheralConnection(o.Ptr(), peripheral.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBCentralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBCentralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBCentralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentralManager_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBCentralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) RetrieveConnectedPeripheralsWithServices(serviceUUIDs *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrieveConnectedPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsLike(object *NSString) bool { - ret := (C.CBCentralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) DoesContain(object NSObject) bool { - ret := (C.CBCentralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsGreaterThan(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) WillChangeValueForKey(key *NSString) { - C.CBCentralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsScanning() bool { - ret := (C.CBCentralManager_inst_IsScanning(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ConnectPeripheral(peripheral *CBPeripheral, options *NSDictionary) { - C.CBCentralManager_inst_ConnectPeripheral(o.Ptr(), peripheral.Ptr(), options.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) StopScan() { - C.CBCentralManager_inst_StopScan(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) Delegate() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Delegate(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBCentralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBCentralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCentralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCentralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBCentralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBCentralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) State() CBManagerState { - ret := (CBManagerState)(C.CBCentralManager_inst_State(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBCentralManager { - ret := &CBCentralManager{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCentralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ScanForPeripheralsWithServices(serviceUUIDs *NSArray, options *NSDictionary) { - C.CBCentralManager_inst_ScanForPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr(), options.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetValueForKey(value NSObject, key *NSString) { - C.CBCentralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBCentralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBCentralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) Dealloc() { - C.CBCentralManager_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetDelegate(delegate NSObject) { - C.CBCentralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) RetrievePeripheralsWithIdentifiers(identifiers *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrievePeripheralsWithIdentifiers(o.Ptr(), identifiers.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ForwardInvocation(anInvocation *NSInvocation) { - C.CBCentralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBCentralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCentralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCentralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCentralManager_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBCentralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentralManager) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBCentralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func CBCentralAccessInstanceVariablesDirectly() bool { - ret := (C.CBCentral_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBCentralAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBCentral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBCentralAlloc() *CBCentral { - ret := &CBCentral{} - ret.ptr = unsafe.Pointer(C.CBCentral_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentral) { - o.Release() - }) - return ret -} - -func (o *CBCentral) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBCentral) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBCentralCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBCentral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBCentralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCentral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCentralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCentral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCentralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCentral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralVersion() NSInteger { - ret := (NSInteger)(C.CBCentral_Version()) - return ret -} - -func CBCentralSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_Superclass())) - return ret -} - -func CBCentralClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralAllocWithZone(zone *_NSZone) *CBCentral { - ret := &CBCentral{} - ret.ptr = unsafe.Pointer(C.CBCentral_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentral) { - o.Release() - }) - return ret -} - -func CBCentralCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCentralMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCentralSetVersion(aVersion NSInteger) { - C.CBCentral_SetVersion((C.NSInteger)(aVersion)) -} - -func CBCentralResolveInstanceMethod(sel SEL) bool { - ret := (C.CBCentral_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCentralInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBCentral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBCentralHash() NSUInteger { - ret := (NSUInteger)(C.CBCentral_Hash()) - return ret -} - -func CBCentralClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_ClassForKeyedUnarchiver())) - return ret -} - -func CBCentralLoad() { - C.CBCentral_Load() -} - -func CBCentralDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentral_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralNew() *CBCentral { - ret := &CBCentral{} - ret.ptr = unsafe.Pointer(C.CBCentral_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCentral) { - o.Release() - }) - return ret -} - -func CBCentralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBCentral_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBCentralClass() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_Class())) - return ret -} - -func CBCentralConformsToProtocol(protocol Protocol) bool { - ret := (C.CBCentral_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBCentralResolveClassMethod(sel SEL) bool { - ret := (C.CBCentral_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCentralIsSubclassOfClass(aClass Class) bool { - ret := (C.CBCentral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBCentralDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentral_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func (o *CBCentral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) IsNotEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ForwardInvocation(anInvocation *NSInvocation) { - C.CBCentral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) SetValueForKey(value NSObject, key *NSString) { - C.CBCentral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBCentral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBCentral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) WillChangeValueForKey(key *NSString) { - C.CBCentral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBCentral_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBCentral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBCentral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MaximumUpdateValueLength() NSUInteger { - ret := (NSUInteger)(C.CBCentral_inst_MaximumUpdateValueLength(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCentral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCentral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) IsLike(object *NSString) bool { - ret := (C.CBCentral_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBCentral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBCentral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBCentral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) Identifier() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_Identifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCentral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DidChangeValueForKey(key *NSString) { - C.CBCentral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCentral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) DoesNotRecognizeSelector(aSelector SEL) { - C.CBCentral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) IsGreaterThan(object NSObject) bool { - ret := (C.CBCentral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingContains(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) DoesContain(object NSObject) bool { - ret := (C.CBCentral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) IsEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentral_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBCentral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBCentral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCentral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBCentral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) IsLessThan(object NSObject) bool { - ret := (C.CBCentral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBCentral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) Dealloc() { - C.CBCentral_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBCentral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBCentral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBCentral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCentral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCentral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCentral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) SetNilValueForKey(key *NSString) { - C.CBCentral_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBCentral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCentral) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBCentral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCentral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCentral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCentral) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCentral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCentral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func CBDescriptorSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_Superclass())) - return ret -} - -func CBDescriptorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBDescriptorMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBDescriptorCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBDescriptorNew() *CBDescriptor { - ret := &CBDescriptor{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBDescriptor) { - o.Release() - }) - return ret -} - -func CBDescriptorCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBDescriptor_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBDescriptorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBDescriptorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBDescriptorAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBDescriptor_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBDescriptorAccessInstanceVariablesDirectly() bool { - ret := (C.CBDescriptor_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBDescriptorSetVersion(aVersion NSInteger) { - C.CBDescriptor_SetVersion((C.NSInteger)(aVersion)) -} - -func CBDescriptorDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBDescriptorIsSubclassOfClass(aClass Class) bool { - ret := (C.CBDescriptor_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBDescriptorClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_ClassForKeyedUnarchiver())) - return ret -} - -func CBDescriptorLoad() { - C.CBDescriptor_Load() -} - -func CBDescriptorResolveClassMethod(sel SEL) bool { - ret := (C.CBDescriptor_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBDescriptorHash() NSUInteger { - ret := (NSUInteger)(C.CBDescriptor_Hash()) - return ret -} - -func CBDescriptorAlloc() *CBDescriptor { - ret := &CBDescriptor{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBDescriptor) { - o.Release() - }) - return ret -} - -func (o *CBDescriptor) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBDescriptor) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBDescriptorClass() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_Class())) - return ret -} - -func CBDescriptorConformsToProtocol(protocol Protocol) bool { - ret := (C.CBDescriptor_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBDescriptorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBDescriptorInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBDescriptor_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBDescriptorResolveInstanceMethod(sel SEL) bool { - ret := (C.CBDescriptor_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBDescriptorVersion() NSInteger { - ret := (NSInteger)(C.CBDescriptor_Version()) - return ret -} - -func CBDescriptorDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBDescriptorClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBDescriptorAllocWithZone(zone *_NSZone) *CBDescriptor { - ret := &CBDescriptor{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBDescriptor) { - o.Release() - }) - return ret -} - -func (o *CBDescriptor) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) IsGreaterThan(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBDescriptor_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBDescriptor_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBDescriptor_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBDescriptor_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBDescriptor_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBDescriptor_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBDescriptor_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBDescriptor_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DoesNotRecognizeSelector(aSelector SEL) { - C.CBDescriptor_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBDescriptor_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DoesContain(object NSObject) bool { - ret := (C.CBDescriptor_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) Characteristic() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Characteristic(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBDescriptor_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBDescriptor_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) IsLike(object *NSString) bool { - ret := (C.CBDescriptor_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBDescriptor_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) IsEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) SetNilValueForKey(key *NSString) { - C.CBDescriptor_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBDescriptor_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBDescriptor_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBDescriptor_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingContains(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBDescriptor_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) UUID() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_UUID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ForwardInvocation(anInvocation *NSInvocation) { - C.CBDescriptor_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) SetValueForKey(value NSObject, key *NSString) { - C.CBDescriptor_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBDescriptor_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBDescriptor_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBDescriptor_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBDescriptor_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBDescriptor_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DidChangeValueForKey(key *NSString) { - C.CBDescriptor_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBDescriptor_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBDescriptor_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBDescriptor_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBDescriptor_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBDescriptor_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) IsNotEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBDescriptor_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBDescriptor_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBDescriptor_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBDescriptor_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBDescriptor_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) IsLessThan(object NSObject) bool { - ret := (C.CBDescriptor_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) WillChangeValueForKey(key *NSString) { - C.CBDescriptor_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBDescriptor) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBDescriptor_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) Value() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Value(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBDescriptor) Dealloc() { - C.CBDescriptor_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func NSArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSArrayHash() NSUInteger { - ret := (NSUInteger)(C.NSArray_Hash()) - return ret -} - -func NSArrayArray() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_Array()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSArrayWithArray(array *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithArray(array.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayAllocWithZone(zone *_NSZone) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayConformsToProtocol(protocol Protocol) bool { - ret := (C.NSArray_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSArraySupportsSecureCoding() bool { - ret := (C.NSArray_SupportsSecureCoding()) != 0 - return ret -} - -func NSArrayWithContentsOfFile(path *NSString) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfFile(path.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayAlloc() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func (o *NSArray) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSArrayLoad() { - C.NSArray_Load() -} - -func NSArrayMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSArrayDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSArrayIsSubclassOfClass(aClass Class) bool { - ret := (C.NSArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSArrayWithContentsOfURL(url *NSURL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURL(url.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { - - goSlice1 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice1[i] = (*error)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice1[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayNew() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayAccessInstanceVariablesDirectly() bool { - ret := (C.NSArray_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSArray_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSArraySetVersion(aVersion NSInteger) { - C.NSArray_SetVersion((C.NSInteger)(aVersion)) -} - -func NSArrayDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSArrayClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_ClassForKeyedUnarchiver())) - return ret -} - -func NSArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray { - - goSlice0 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice0[i] = (*objects)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice0[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice0[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSArray { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSArrayClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSArrayResolveInstanceMethod(sel SEL) bool { - ret := (C.NSArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSArrayResolveClassMethod(sel SEL) bool { - ret := (C.NSArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSArrayInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSArraySuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_Superclass())) - return ret -} - -func NSArrayVersion() NSInteger { - ret := (NSInteger)(C.NSArray_Version()) - return ret -} - -func NSArrayClass() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_Class())) - return ret -} - -func NSArrayWithObject(anObject NSObject) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObject(anObject.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func (o *NSArray) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) LastObject() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_LastObject(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ReverseObjectEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ReverseObjectEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSArray { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) WriteToURLError(url *NSURL, error *[]*NSError) bool { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := (C.NSArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { - ret := (C.NSArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { - ret := (C.NSArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ContainsObject(anObject NSObject) bool { - ret := (C.NSArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsLessThan(object NSObject) bool { - ret := (C.NSArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SetValueForKey(value NSObject, key *NSString) { - C.NSArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) SubarrayWithRange(range_ NSRange) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) DoesNotRecognizeSelector(aSelector SEL) { - C.NSArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSArray) MakeObjectsPerformSelector(aSelector SEL) { - C.NSArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject) { - C.NSArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingContains(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ComponentsJoinedByString(separator *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithArray(array *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArray(o.Ptr(), array.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IndexOfObject(anObject NSObject) NSUInteger { - ret := (NSUInteger)(C.NSArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger { - ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSArray_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsNotEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) Dealloc() { - C.NSArray_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) IsGreaterThan(object NSObject) bool { - ret := (C.NSArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObjectAtIndex(index NSUInteger) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) DescriptionWithLocale(locale NSObject) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ForwardInvocation(anInvocation *NSInvocation) { - C.NSArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableCopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ArrayByAddingObject(anObject NSObject) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) InitWithContentsOfURL(url *NSURL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) DidChangeValueForKey(key *NSString) { - C.NSArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsLike(object *NSString) bool { - ret := (C.NSArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { - C.NSArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { - C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer) { - C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSArray) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) WillChangeValueForKey(key *NSString) { - C.NSArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) InitWithCoder(aDecoder *NSCoder) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SortedArrayUsingSelector(comparator SEL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) DoesContain(object NSObject) bool { - ret := (C.NSArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) Init() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) FirstObject() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObject(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) InitWithContentsOfFile(path *NSString) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger { - ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger { - ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SortedArrayHint() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayHint(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) GetObjectsRange(objects *[]*Id, range_ NSRange) { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - C.NSArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_)) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - runtime.KeepAlive(o) -} - -func (o *NSArray) Count() NSUInteger { - ret := (NSUInteger)(C.NSArray_inst_Count(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) SetNilValueForKey(key *NSString) { - C.NSArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSArray) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObjectEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsEqualToArray(otherArray *NSArray) bool { - ret := (C.NSArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSArray_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSArray_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSArray) IsEqualTo(object NSObject) bool { - ret := (C.NSArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func NSMutableArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSMutableArrayCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSMutableArrayConformsToProtocol(protocol Protocol) bool { - ret := (C.NSMutableArray_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSMutableArrayDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSMutableArrayClass() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_Class())) - return ret -} - -func NSMutableArrayArray() *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_Array()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayAlloc() *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func (o *NSMutableArray) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSMutableArrayLoad() { - C.NSMutableArray_Load() -} - -func NSMutableArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSMutableArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSMutableArrayVersion() NSInteger { - ret := (NSInteger)(C.NSMutableArray_Version()) - return ret -} - -func NSMutableArrayWithArray(array *NSArray) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithArray(array.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayIsSubclassOfClass(aClass Class) bool { - ret := (C.NSMutableArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSMutableArrayResolveClassMethod(sel SEL) bool { - ret := (C.NSMutableArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSMutableArrayNew() *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSMutableArraySuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_Superclass())) - return ret -} - -func NSMutableArrayWithObject(anObject NSObject) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObject(anObject.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayHash() NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_Hash()) - return ret -} - -func NSMutableArrayAccessInstanceVariablesDirectly() bool { - ret := (C.NSMutableArray_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSMutableArrayWithCapacity(numItems NSUInteger) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithCapacity((C.NSUInteger)(numItems))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayAllocWithZone(zone *_NSZone) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSMutableArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSMutableArraySetVersion(aVersion NSInteger) { - C.NSMutableArray_SetVersion((C.NSInteger)(aVersion)) -} - -func NSMutableArrayDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSMutableArrayWithContentsOfURL(url *NSURL) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURL(url.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { - - goSlice1 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice1[i] = (*error)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice1[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - return ret -} - -func NSMutableArraySupportsSecureCoding() bool { - ret := (C.NSMutableArray_SupportsSecureCoding()) != 0 - return ret -} - -func NSMutableArrayClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSMutableArrayResolveInstanceMethod(sel SEL) bool { - ret := (C.NSMutableArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSMutableArrayInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSMutableArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSMutableArrayWithContentsOfFile(path *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfFile(path.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSMutableArrayClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_ClassForKeyedUnarchiver())) - return ret -} - -func NSMutableArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray { - - goSlice0 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice0[i] = (*objects)[i].Ptr() - } - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice0[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice0[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func NSMutableArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - return ret -} - -func (o *NSMutableArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSMutableArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) RemoveObjectsInRange(range_ NSRange) { - C.NSMutableArray_inst_RemoveObjectsInRange(o.Ptr(), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSMutableArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MutableCopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsGreaterThan(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObjectEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SortedArrayHint() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayHint(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSMutableArray_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ContainsObject(anObject NSObject) bool { - ret := (C.NSMutableArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsLike(object *NSString) bool { - ret := (C.NSMutableArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ExchangeObjectAtIndexWithObjectAtIndex(idx1 NSUInteger, idx2 NSUInteger) { - C.NSMutableArray_inst_ExchangeObjectAtIndexWithObjectAtIndex(o.Ptr(), (C.NSUInteger)(idx1), (C.NSUInteger)(idx2)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSMutableArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DoesNotRecognizeSelector(aSelector SEL) { - C.NSMutableArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SortUsingDescriptors(sortDescriptors *NSArray) { - C.NSMutableArray_inst_SortUsingDescriptors(o.Ptr(), sortDescriptors.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) SetValueForKey(value NSObject, key *NSString) { - C.NSMutableArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSMutableArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSMutableArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSMutableArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSMutableArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSMutableArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSMutableArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DoesContain(object NSObject) bool { - ret := (C.NSMutableArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) RemoveObjectsAtIndexes(indexes *NSIndexSet) { - C.NSMutableArray_inst_RemoveObjectsAtIndexes(o.Ptr(), indexes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSMutableArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) Dealloc() { - C.NSMutableArray_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReverseObjectEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReverseObjectEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSMutableArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingContains(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSMutableArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSMutableArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { - C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { - C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer) { - C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArray(range_ NSRange, otherArray *NSArray) { - C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArray(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArrayRange(range_ NSRange, otherArray *NSArray, otherRange NSRange) { - C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArrayRange(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr(), (C.NSRange)(otherRange)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveAllObjects() { - C.NSMutableArray_inst_RemoveAllObjects(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) Init() *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SortedArrayUsingSelector(comparator SEL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DidChangeValueForKey(key *NSString) { - C.NSMutableArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithContentsOfURL(url *NSURL) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReplaceObjectAtIndexWithObject(index NSUInteger, anObject NSObject) { - C.NSMutableArray_inst_ReplaceObjectAtIndexWithObject(o.Ptr(), (C.NSUInteger)(index), anObject.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InitWithContentsOfFile(path *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSMutableArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSMutableArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) Count() NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_inst_Count(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) FilterUsingPredicate(predicate *NSPredicate) { - C.NSMutableArray_inst_FilterUsingPredicate(o.Ptr(), predicate.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObject(anObject NSObject) { - C.NSMutableArray_inst_AddObject(o.Ptr(), anObject.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) LastObject() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_LastObject(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithCoder(aDecoder *NSCoder) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DescriptionWithLocale(locale NSObject) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ArrayByAddingObject(anObject NSObject) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) WriteToURLError(url *NSURL, error *[]*NSError) bool { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := (C.NSMutableArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { - ret := (C.NSMutableArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ComponentsJoinedByString(separator *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ObjectAtIndex(index NSUInteger) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { - ret := (C.NSMutableArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SubarrayWithRange(range_ NSRange) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InsertObjectsAtIndexes(objects *NSArray, indexes *NSIndexSet) { - C.NSMutableArray_inst_InsertObjectsAtIndexes(o.Ptr(), objects.Ptr(), indexes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) FirstObject() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObject(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReplaceObjectsAtIndexesWithObjects(indexes *NSIndexSet, objects *NSArray) { - C.NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(o.Ptr(), indexes.Ptr(), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InitWithArray(array *NSArray) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArray(o.Ptr(), array.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSMutableArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSMutableArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSMutableArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ForwardInvocation(anInvocation *NSInvocation) { - C.NSMutableArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) RemoveObjectAtIndex(index NSUInteger) { - C.NSMutableArray_inst_RemoveObjectAtIndex(o.Ptr(), (C.NSUInteger)(index)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObject(anObject NSObject) { - C.NSMutableArray_inst_RemoveObject(o.Ptr(), anObject.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObjectInRange(anObject NSObject, range_ NSRange) { - C.NSMutableArray_inst_RemoveObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InitWithCapacity(numItems NSUInteger) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCapacity(o.Ptr(), (C.NSUInteger)(numItems))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IndexOfObject(anObject NSObject) NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger { - ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) IsLessThan(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) GetObjectsRange(objects *[]*Id, range_ NSRange) { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - C.NSMutableArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_)) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObjectsFromArray(otherArray *NSArray) { - C.NSMutableArray_inst_AddObjectsFromArray(o.Ptr(), otherArray.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSMutableArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SetArray(otherArray *NSArray) { - C.NSMutableArray_inst_SetArray(o.Ptr(), otherArray.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSMutableArray_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SetNilValueForKey(key *NSString) { - C.NSMutableArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) IsEqualToArray(otherArray *NSArray) bool { - ret := (C.NSMutableArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) WillChangeValueForKey(key *NSString) { - C.NSMutableArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SortUsingSelector(comparator SEL) { - C.NSMutableArray_inst_SortUsingSelector(o.Ptr(), unsafe.Pointer(comparator)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObjectIdenticalTo(anObject NSObject) { - C.NSMutableArray_inst_RemoveObjectIdenticalTo(o.Ptr(), anObject.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveObjectIdenticalToInRange(anObject NSObject, range_ NSRange) { - C.NSMutableArray_inst_RemoveObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) RemoveLastObject() { - C.NSMutableArray_inst_RemoveLastObject(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSMutableArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSMutableArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSMutableArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSMutableArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSMutableArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSMutableArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSMutableArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSMutableArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSMutableArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) SetObjectAtIndexedSubscript(obj NSObject, idx NSUInteger) { - C.NSMutableArray_inst_SetObjectAtIndexedSubscript(o.Ptr(), obj.Ptr(), (C.NSUInteger)(idx)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) InsertObjectAtIndex(anObject NSObject, index NSUInteger) { - C.NSMutableArray_inst_InsertObjectAtIndex(o.Ptr(), anObject.Ptr(), (C.NSUInteger)(index)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) MakeObjectsPerformSelector(aSelector SEL) { - C.NSMutableArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject) { - C.NSMutableArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) RemoveObjectsInArray(otherArray *NSArray) { - C.NSMutableArray_inst_RemoveObjectsInArray(o.Ptr(), otherArray.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) IsNotEqualTo(object NSObject) bool { - ret := (C.NSMutableArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSMutableArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSMutableArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSMutableArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSMutableArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func NSDictionaryWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeys(objects.Ptr(), keys.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary { - - goSlice0 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice0[i] = (*objects)[i].Ptr() - } - - goSlice1 := make([]unsafe.Pointer,cap(*keys)) - for i := 0; i < len(*keys); i++ { - goSlice1[i] = (*keys)[i].Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeysCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice0[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice0[i] - } - (*keys) = (*keys)[:cap(*keys)] - for i := 0; i < len(*keys); i++ { - if goSlice1[i] == nil { - (*keys) = (*keys)[:i] - break - } - if (*keys)[i] == nil { - (*keys)[i] = &Id{} - runtime.SetFinalizer((*keys)[i], func(o *Id) { - o.Release() - }) - } - (*keys)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionarySharedKeySetForKeys(keys *NSArray) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_SharedKeySetForKeys(keys.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionaryClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_ClassForKeyedUnarchiver())) - return ret -} - -func NSDictionaryWithDictionary(dict *NSDictionary) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithDictionary(dict.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryWithContentsOfURL(url *NSURL) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURL(url.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary { - - goSlice1 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice1[i] = (*error)[i].Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice1[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice1[i] - } - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryWithObjectForKey(object NSObject, key NSObject) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectForKey(object.Ptr(), key.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSDictionary_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSDictionaryResolveInstanceMethod(sel SEL) bool { - ret := (C.NSDictionary_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSDictionaryClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionaryAllocWithZone(zone *_NSZone) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryClass() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_Class())) - return ret -} - -func NSDictionaryConformsToProtocol(protocol Protocol) bool { - ret := (C.NSDictionary_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSDictionaryDictionary() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_Dictionary()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryVersion() NSInteger { - ret := (NSInteger)(C.NSDictionary_Version()) - return ret -} - -func NSDictionaryAccessInstanceVariablesDirectly() bool { - ret := (C.NSDictionary_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSDictionaryLoad() { - C.NSDictionary_Load() -} - -func NSDictionaryCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSDictionary_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSDictionaryCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSDictionaryCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSDictionaryIsSubclassOfClass(aClass Class) bool { - ret := (C.NSDictionary_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSDictionaryAlloc() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func (o *NSDictionary) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSDictionaryWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsAndKeys(firstObject.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryNew() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSDictionaryDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionaryInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSDictionary_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSDictionarySupportsSecureCoding() bool { - ret := (C.NSDictionary_SupportsSecureCoding()) != 0 - return ret -} - -func NSDictionaryWithContentsOfFile(path *NSString) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfFile(path.Ptr())) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - return ret -} - -func NSDictionaryInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSDictionary_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionarySuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_Superclass())) - return ret -} - -func NSDictionarySetVersion(aVersion NSInteger) { - C.NSDictionary_SetVersion((C.NSInteger)(aVersion)) -} - -func NSDictionaryResolveClassMethod(sel SEL) bool { - ret := (C.NSDictionary_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSDictionaryHash() NSUInteger { - ret := (NSUInteger)(C.NSDictionary_Hash()) - return ret -} - -func NSDictionaryKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSDictionary_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionaryDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSDictionaryMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func (o *NSDictionary) InitWithContentsOfURL(url *NSURL) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DescriptionWithLocale(locale NSObject) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ForwardInvocation(anInvocation *NSInvocation) { - C.NSDictionary_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSDictionary_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSDictionary_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSDictionary_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSDictionary_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSDictionary_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) WriteToURLError(url *NSURL, error *[]*NSError) bool { - - goSlice2 := make([]unsafe.Pointer,cap(*error)) - for i := 0; i < len(*error); i++ { - goSlice2[i] = (*error)[i].Ptr() - } - ret := (C.NSDictionary_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 - (*error) = (*error)[:cap(*error)] - for i := 0; i < len(*error); i++ { - if goSlice2[i] == nil { - (*error) = (*error)[:i] - break - } - if (*error)[i] == nil { - (*error)[i] = &NSError{} - runtime.SetFinalizer((*error)[i], func(o *NSError) { - o.Release() - }) - } - (*error)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { - ret := (C.NSDictionary_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) KeyEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeyEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSDictionary_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSDictionary_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSDictionary_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSDictionary_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSDictionary_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSDictionary_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSDictionary_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { - ret := (C.NSDictionary_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileGroupOwnerAccountID() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) SetValueForKey(value NSObject, key *NSString) { - C.NSDictionary_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSDictionary_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSDictionary_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableCopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) GetObjectsAndKeys(objects *[]*Id, keys *[]*Id, count NSUInteger) { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - - goSlice2 := make([]unsafe.Pointer,cap(*keys)) - for i := 0; i < len(*keys); i++ { - goSlice2[i] = (*keys)[i].Ptr() - } - C.NSDictionary_inst_GetObjectsAndKeys(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count)) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - (*keys) = (*keys)[:cap(*keys)] - for i := 0; i < len(*keys); i++ { - if goSlice2[i] == nil { - (*keys) = (*keys)[:i] - break - } - if (*keys)[i] == nil { - (*keys)[i] = &Id{} - runtime.SetFinalizer((*keys)[i], func(o *Id) { - o.Release() - }) - } - (*keys)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) -} - -func (o *NSDictionary) GetObjectsAndKeysCount(objects *[]*Id, keys *[]*Id, count NSUInteger) { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - - goSlice2 := make([]unsafe.Pointer,cap(*keys)) - for i := 0; i < len(*keys); i++ { - goSlice2[i] = (*keys)[i].Ptr() - } - C.NSDictionary_inst_GetObjectsAndKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count)) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - (*keys) = (*keys)[:cap(*keys)] - for i := 0; i < len(*keys); i++ { - if goSlice2[i] == nil { - (*keys) = (*keys)[:i] - break - } - if (*keys)[i] == nil { - (*keys)[i] = &Id{} - runtime.SetFinalizer((*keys)[i], func(o *Id) { - o.Release() - }) - } - (*keys)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) -} - -func (o *NSDictionary) FileOwnerAccountName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileHFSTypeCode() OSType { - ret := (OSType)(C.NSDictionary_inst_FileHFSTypeCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSDictionary_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileGroupOwnerAccountName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) KeysSortedByValueUsingSelector(comparator SEL) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeysSortedByValueUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsLike(object *NSString) bool { - ret := (C.NSDictionary_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSDictionary_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSDictionary_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) InitWithCoder(aDecoder *NSCoder) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObjectEnumerator() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectEnumerator(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithContentsOfFile(path *NSString) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObjectForKeyedSubscript(key NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKeyedSubscript(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileSystemNumber() NSInteger { - ret := (NSInteger)(C.NSDictionary_inst_FileSystemNumber(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObjectForKey(aKey NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKey(o.Ptr(), aKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileIsImmutable() bool { - ret := (C.NSDictionary_inst_FileIsImmutable(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsEqualToDictionary(otherDictionary *NSDictionary) bool { - ret := (C.NSDictionary_inst_IsEqualToDictionary(o.Ptr(), otherDictionary.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeys(o.Ptr(), objects.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary { - - goSlice1 := make([]unsafe.Pointer,cap(*objects)) - for i := 0; i < len(*objects); i++ { - goSlice1[i] = (*objects)[i].Ptr() - } - - goSlice2 := make([]unsafe.Pointer,cap(*keys)) - for i := 0; i < len(*keys); i++ { - goSlice2[i] = (*keys)[i].Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(cnt))) - (*objects) = (*objects)[:cap(*objects)] - for i := 0; i < len(*objects); i++ { - if goSlice1[i] == nil { - (*objects) = (*objects)[:i] - break - } - if (*objects)[i] == nil { - (*objects)[i] = &Id{} - runtime.SetFinalizer((*objects)[i], func(o *Id) { - o.Release() - }) - } - (*objects)[i].ptr = goSlice1[i] - } - (*keys) = (*keys)[:cap(*keys)] - for i := 0; i < len(*keys); i++ { - if goSlice2[i] == nil { - (*keys) = (*keys)[:i] - break - } - if (*keys)[i] == nil { - (*keys)[i] = &Id{} - runtime.SetFinalizer((*keys)[i], func(o *Id) { - o.Release() - }) - } - (*keys)[i].ptr = goSlice2[i] - } - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSDictionary_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSDictionary_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ScriptingContains(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileHFSCreatorCode() OSType { - ret := (OSType)(C.NSDictionary_inst_FileHFSCreatorCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSDictionary_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DoesContain(object NSObject) bool { - ret := (C.NSDictionary_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileOwnerAccountID() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AllKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsGreaterThan(object NSObject) bool { - ret := (C.NSDictionary_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSDictionary_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) DescriptionInStringsFileFormat() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionInStringsFileFormat(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSDictionary_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSDictionary_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObjectsForKeysNotFoundMarker(keys *NSArray, marker NSObject) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectsForKeysNotFoundMarker(o.Ptr(), keys.Ptr(), marker.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileType() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileType(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FilePosixPermissions() NSUInteger { - ret := (NSUInteger)(C.NSDictionary_inst_FilePosixPermissions(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSDictionary_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) Init() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AllValues() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllValues(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSDictionary_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DidChangeValueForKey(key *NSString) { - C.NSDictionary_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSDictionary_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSDictionary_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSDictionary_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) WillChangeValueForKey(key *NSString) { - C.NSDictionary_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSDictionary_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSDictionary_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) FileSystemFileNumber() NSUInteger { - ret := (NSUInteger)(C.NSDictionary_inst_FileSystemFileNumber(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) Count() NSUInteger { - ret := (NSUInteger)(C.NSDictionary_inst_Count(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSDictionary_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) FileExtensionHidden() bool { - ret := (C.NSDictionary_inst_FileExtensionHidden(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DoesNotRecognizeSelector(aSelector SEL) { - C.NSDictionary_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileCreationDate() *NSDate { - ret := &NSDate{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileCreationDate(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDate) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AllKeysForObject(anObject NSObject) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeysForObject(o.Ptr(), anObject.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileModificationDate() *NSDate { - ret := &NSDate{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileModificationDate(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDate) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary { - var object [16]unsafe.Pointer - for i,o := range objects { - object[i] = o.Ptr() - } - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsAndKeys(o.Ptr(), firstObject.Ptr(), unsafe.Pointer(&object))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSDictionary_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSDictionary_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithDictionary(otherDictionary *NSDictionary) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionary(o.Ptr(), otherDictionary.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) InitWithDictionaryCopyItems(otherDictionary *NSDictionary, flag BOOL) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionaryCopyItems(o.Ptr(), otherDictionary.Ptr(), (C.BOOL)(flag))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSDictionary_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSDictionary_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) IsNotEqualTo(object NSObject) bool { - ret := (C.NSDictionary_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) FileIsAppendOnly() bool { - ret := (C.NSDictionary_inst_FileIsAppendOnly(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) IsLessThan(object NSObject) bool { - ret := (C.NSDictionary_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) SetNilValueForKey(key *NSString) { - C.NSDictionary_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSDictionary_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) Dealloc() { - C.NSDictionary_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSDictionary) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSDictionary_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSDictionary_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSDictionary) FileSize() UnsignedLongLong { - ret := (UnsignedLongLong)(C.NSDictionary_inst_FileSize(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func NSEnumeratorInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSEnumerator_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSEnumeratorCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSEnumerator_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSEnumeratorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSEnumeratorNew() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - return ret -} - -func NSEnumeratorResolveInstanceMethod(sel SEL) bool { - ret := (C.NSEnumerator_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSEnumeratorIsSubclassOfClass(aClass Class) bool { - ret := (C.NSEnumerator_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSEnumeratorClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_ClassForKeyedUnarchiver())) - return ret -} - -func NSEnumeratorClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSEnumeratorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSEnumeratorAllocWithZone(zone *_NSZone) *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - return ret -} - -func NSEnumeratorResolveClassMethod(sel SEL) bool { - ret := (C.NSEnumerator_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSEnumeratorHash() NSUInteger { - ret := (NSUInteger)(C.NSEnumerator_Hash()) - return ret -} - -func NSEnumeratorAlloc() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - return ret -} - -func (o *NSEnumerator) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSEnumeratorAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSEnumerator_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSEnumeratorSetVersion(aVersion NSInteger) { - C.NSEnumerator_SetVersion((C.NSInteger)(aVersion)) -} - -func NSEnumeratorCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSEnumeratorDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSEnumeratorClass() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_Class())) - return ret -} - -func NSEnumeratorConformsToProtocol(protocol Protocol) bool { - ret := (C.NSEnumerator_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSEnumeratorDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSEnumeratorLoad() { - C.NSEnumerator_Load() -} - -func NSEnumeratorVersion() NSInteger { - ret := (NSInteger)(C.NSEnumerator_Version()) - return ret -} - -func NSEnumeratorAccessInstanceVariablesDirectly() bool { - ret := (C.NSEnumerator_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSEnumeratorSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_Superclass())) - return ret -} - -func NSEnumeratorMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func (o *NSEnumerator) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { - - goSlice2 := make([]unsafe.Pointer,cap(*buffer)) - for i := 0; i < len(*buffer); i++ { - goSlice2[i] = (*buffer)[i].Ptr() - } - ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) - (*buffer) = (*buffer)[:cap(*buffer)] - for i := 0; i < len(*buffer); i++ { - if goSlice2[i] == nil { - (*buffer) = (*buffer)[:i] - break - } - if (*buffer)[i] == nil { - (*buffer)[i] = &Id{} - runtime.SetFinalizer((*buffer)[i], func(o *Id) { - o.Release() - }) - } - (*buffer)[i].ptr = goSlice2[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSEnumerator_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSEnumerator_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSEnumerator_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSEnumerator_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DoesNotRecognizeSelector(aSelector SEL) { - C.NSEnumerator_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DidChangeValueForKey(key *NSString) { - C.NSEnumerator_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSEnumerator_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) NextObject() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NextObject(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsGreaterThan(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSEnumerator_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) SetNilValueForKey(key *NSString) { - C.NSEnumerator_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSEnumerator_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSEnumerator_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) IsNotEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) Dealloc() { - C.NSEnumerator_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSEnumerator_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) IsLessThan(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSEnumerator_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) WillChangeValueForKey(key *NSString) { - C.NSEnumerator_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSEnumerator_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSEnumerator_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsLike(object *NSString) bool { - ret := (C.NSEnumerator_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSEnumerator_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSEnumerator_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSEnumerator_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSEnumerator_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AllObjects() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AllObjects(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSEnumerator_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSEnumerator_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ForwardInvocation(anInvocation *NSInvocation) { - C.NSEnumerator_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSEnumerator_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSEnumerator_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSEnumerator_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) SetValueForKey(value NSObject, key *NSString) { - C.NSEnumerator_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSEnumerator_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSEnumerator_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSEnumerator_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSEnumerator_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSEnumerator_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSEnumerator_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ScriptingContains(object NSObject) bool { - ret := (C.NSEnumerator_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSEnumerator_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) DoesContain(object NSObject) bool { - ret := (C.NSEnumerator_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSEnumerator_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSEnumerator_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSEnumerator_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSEnumerator) Init() *NSEnumerator { - ret := &NSEnumerator{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSEnumerator) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSEnumerator) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func NSObjectMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSObjectAllocWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSObjectConformsToProtocol(protocol Protocol) bool { - ret := (C.NSObject_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSObjectCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSObjectDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSObjectClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_ClassForKeyedUnarchiver())) - return ret -} - -func NSObjectSetVersion(aVersion NSInteger) { - C.NSObject_SetVersion((C.NSInteger)(aVersion)) -} - -func NSObjectClass() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_Class())) - return ret -} - -func NSObjectInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSObject_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSObjectInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSObject_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSObjectAccessInstanceVariablesDirectly() bool { - ret := (C.NSObject_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSObjectSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_Superclass())) - return ret -} - -func NSObjectClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSObject_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSObjectKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSObject_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSObjectAlloc() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func (o *Id) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSObjectCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSObject_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSObjectCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSObject_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSObjectCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSObject_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSObjectResolveClassMethod(sel SEL) bool { - ret := (C.NSObject_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSObjectIsSubclassOfClass(aClass Class) bool { - ret := (C.NSObject_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSObjectDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSObjectVersion() NSInteger { - ret := (NSInteger)(C.NSObject_Version()) - return ret -} - -func NSObjectNew() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSObjectAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSObject_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSObjectResolveInstanceMethod(sel SEL) bool { - ret := (C.NSObject_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSObjectHash() NSUInteger { - ret := (NSUInteger)(C.NSObject_Hash()) - return ret -} - -func NSObjectLoad() { - C.NSObject_Load() -} - -func (o *Id) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSObject_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *Id) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSObject_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *Id) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) WillChangeValueForKey(key *NSString) { - C.NSObject_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSObject_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSObject_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsNotEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsGreaterThan(object NSObject) bool { - ret := (C.NSObject_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSObject_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSObject_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *Id) Hash() NSUInteger { - ret := (NSUInteger)(C.NSObject_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsLike(object *NSString) bool { - ret := (C.NSObject_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) SetNilValueForKey(key *NSString) { - C.NSObject_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingContains(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DoesNotRecognizeSelector(aSelector SEL) { - C.NSObject_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsProxy() bool { - ret := (C.NSObject_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DidChangeValueForKey(key *NSString) { - C.NSObject_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSObject_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSObject_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) SetValueForKey(value NSObject, key *NSString) { - C.NSObject_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSObject_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSObject_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSObject_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSObject_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsEqual(object NSObject) bool { - ret := (C.NSObject_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSObject_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ForwardInvocation(anInvocation *NSInvocation) { - C.NSObject_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.NSObject_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSObject_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *Id) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSObject_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *Id) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSObject_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSObject_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Retain() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) RespondsToSelector(aSelector SEL) bool { - ret := (C.NSObject_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSObject_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSObject_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) DoesContain(object NSObject) bool { - ret := (C.NSObject_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsLessThan(object NSObject) bool { - ret := (C.NSObject_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSObject_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSObject_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSObject_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSObject_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSObject_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSObject_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.NSObject_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Self() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) IsKindOfClass(aClass Class) bool { - ret := (C.NSObject_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Release() { - C.NSObject_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) IsMemberOfClass(aClass Class) bool { - ret := (C.NSObject_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSObject_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSObject_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSObject_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSObject_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSObject_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *Id) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSObject_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *Id) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.NSObject_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Autorelease() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) RetainCount() NSUInteger { - ret := (NSUInteger)(C.NSObject_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Dealloc() { - C.NSObject_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSObject_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSObject_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSObject_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSObject_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *Id) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSObject_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *Id) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSObject_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *Id) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) Init() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSObject_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *Id) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSObject_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func CBPeripheralManagerDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralManagerClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_ClassForKeyedUnarchiver())) - return ret -} - -func CBPeripheralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBPeripheralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBPeripheralManagerAccessInstanceVariablesDirectly() bool { - ret := (C.CBPeripheralManager_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBPeripheralManagerMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBPeripheralManagerClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBPeripheralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBPeripheralManagerHash() NSUInteger { - ret := (NSUInteger)(C.CBPeripheralManager_Hash()) - return ret -} - -func CBPeripheralManagerAllocWithZone(zone *_NSZone) *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - return ret -} - -func CBPeripheralManagerResolveInstanceMethod(sel SEL) bool { - ret := (C.CBPeripheralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBPeripheralManagerNew() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - return ret -} - -func CBPeripheralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralManagerSetVersion(aVersion NSInteger) { - C.CBPeripheralManager_SetVersion((C.NSInteger)(aVersion)) -} - -func CBPeripheralManagerDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralManagerCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func GetCBPeripheralManagerAuthorizationStatus() CBPeripheralManagerAuthorizationStatus { - ret := (CBPeripheralManagerAuthorizationStatus)(C.CBPeripheralManager_AuthorizationStatus()) - return ret -} - -func CBPeripheralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralManagerClass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Class())) - return ret -} - -func CBPeripheralManagerResolveClassMethod(sel SEL) bool { - ret := (C.CBPeripheralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBPeripheralManagerLoad() { - C.CBPeripheralManager_Load() -} - -func CBPeripheralManagerSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Superclass())) - return ret -} - -func CBPeripheralManagerConformsToProtocol(protocol Protocol) bool { - ret := (C.CBPeripheralManager_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBPeripheralManagerIsSubclassOfClass(aClass Class) bool { - ret := (C.CBPeripheralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBPeripheralManagerVersion() NSInteger { - ret := (NSInteger)(C.CBPeripheralManager_Version()) - return ret -} - -func CBPeripheralManagerAlloc() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - return ret -} - -func (o *CBPeripheralManager) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBPeripheralManagerInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBPeripheralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func (o *CBPeripheralManager) ScriptingContains(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) RemoveAllServices() { - C.CBPeripheralManager_inst_RemoveAllServices(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheralManager_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBPeripheralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AddService(service *CBMutableService) { - C.CBPeripheralManager_inst_AddService(o.Ptr(), service.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsProxy() bool { - ret := (C.CBPeripheralManager_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Self() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBPeripheralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) DoesContain(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) DoesNotRecognizeSelector(aSelector SEL) { - C.CBPeripheralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsEqual(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Dealloc() { - C.CBPeripheralManager_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.CBPeripheralManager_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Autorelease() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) StartAdvertising(advertisementData *NSDictionary) { - C.CBPeripheralManager_inst_StartAdvertising(o.Ptr(), advertisementData.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBPeripheralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) DidChangeValueForKey(key *NSString) { - C.CBPeripheralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) UpdateValue(value *NSData, characteristic *CBMutableCharacteristic, centrals *NSArray) bool { - ret := (C.CBPeripheralManager_inst_UpdateValue(o.Ptr(), value.Ptr(), characteristic.Ptr(), centrals.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Init() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBPeripheralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBPeripheralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBPeripheralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBPeripheralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBPeripheralManager_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) IsKindOfClass(aClass Class) bool { - ret := (C.CBPeripheralManager_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBPeripheralManager_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RetainCount() NSUInteger { - ret := (NSUInteger)(C.CBPeripheralManager_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RemoveService(service *CBMutableService) { - C.CBPeripheralManager_inst_RemoveService(o.Ptr(), service.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBPeripheralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RespondsToSelector(aSelector SEL) bool { - ret := (C.CBPeripheralManager_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) SetNilValueForKey(key *NSString) { - C.CBPeripheralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) WillChangeValueForKey(key *NSString) { - C.CBPeripheralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBPeripheralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Retain() *CBPeripheralManager { - ret := &CBPeripheralManager{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) StopAdvertising() { - C.CBPeripheralManager_inst_StopAdvertising(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsNotEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetDelegate(delegate NSObject) { - C.CBPeripheralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBPeripheralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.CBPeripheralManager_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) RespondToRequest(request *CBATTRequest, result CBATTError) { - C.CBPeripheralManager_inst_RespondToRequest(o.Ptr(), request.Ptr(), (C.CBATTError)(result)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetValueForKey(value NSObject, key *NSString) { - C.CBPeripheralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBPeripheralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBPeripheralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) State() CBManagerState { - ret := (CBManagerState)(C.CBPeripheralManager_inst_State(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Delegate() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Delegate(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) IsAdvertising() bool { - ret := (C.CBPeripheralManager_inst_IsAdvertising(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBPeripheralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBPeripheralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBPeripheralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBPeripheralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsLike(object *NSString) bool { - ret := (C.CBPeripheralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) SetDesiredConnectionLatency(latency CBPeripheralManagerConnectionLatency, central *CBCentral) { - C.CBPeripheralManager_inst_SetDesiredConnectionLatency(o.Ptr(), (C.CBPeripheralManagerConnectionLatency)(latency), central.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ForwardInvocation(anInvocation *NSInvocation) { - C.CBPeripheralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBPeripheralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsGreaterThan(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsMemberOfClass(aClass Class) bool { - ret := (C.CBPeripheralManager_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Hash() NSUInteger { - ret := (NSUInteger)(C.CBPeripheralManager_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) IsLessThan(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) Release() { - C.CBPeripheralManager_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBPeripheralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBPeripheralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBPeripheralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBPeripheralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheralManager) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func CBCharacteristicClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_ClassForKeyedUnarchiver())) - return ret -} - -func CBCharacteristicResolveClassMethod(sel SEL) bool { - ret := (C.CBCharacteristic_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCharacteristicDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCharacteristicNew() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - return ret -} - -func CBCharacteristicClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func CBCharacteristicInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func CBCharacteristicVersion() NSInteger { - ret := (NSInteger)(C.CBCharacteristic_Version()) - return ret -} - -func CBCharacteristicHash() NSUInteger { - ret := (NSUInteger)(C.CBCharacteristic_Hash()) - return ret -} - -func CBCharacteristicInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBCharacteristic_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func CBCharacteristicAlloc() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - return ret -} - -func (o *CBCharacteristic) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *CBCharacteristic) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func CBCharacteristicMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCharacteristicAllocWithZone(zone *_NSZone) *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - return ret -} - -func CBCharacteristicResolveInstanceMethod(sel SEL) bool { - ret := (C.CBCharacteristic_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func CBCharacteristicCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBCharacteristic_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBCharacteristicSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Superclass())) - return ret -} - -func CBCharacteristicLoad() { - C.CBCharacteristic_Load() -} - -func CBCharacteristicConformsToProtocol(protocol Protocol) bool { - ret := (C.CBCharacteristic_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBCharacteristicIsSubclassOfClass(aClass Class) bool { - ret := (C.CBCharacteristic_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBCharacteristicAccessInstanceVariablesDirectly() bool { - ret := (C.CBCharacteristic_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBCharacteristicKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func CBCharacteristicSetVersion(aVersion NSInteger) { - C.CBCharacteristic_SetVersion((C.NSInteger)(aVersion)) -} - -func CBCharacteristicCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBCharacteristicAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBCharacteristic_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func CBCharacteristicClass() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Class())) - return ret -} - -func CBCharacteristicDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func (o *CBCharacteristic) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBCharacteristic_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) Autorelease() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Descriptors() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Descriptors(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBCharacteristic_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Dealloc() { - C.CBCharacteristic_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) RespondsToSelector(aSelector SEL) bool { - ret := (C.CBCharacteristic_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsKindOfClass(aClass Class) bool { - ret := (C.CBCharacteristic_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) DidChangeValueForKey(key *NSString) { - C.CBCharacteristic_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBCharacteristic_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsEqual(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsMemberOfClass(aClass Class) bool { - ret := (C.CBCharacteristic_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBCharacteristic_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBCharacteristic_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCharacteristic_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCharacteristic_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBCharacteristic_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.CBCharacteristic_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Value() *NSData { - ret := &NSData{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Value(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSData) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) UUID() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_UUID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Properties() CBCharacteristicProperties { - ret := (CBCharacteristicProperties)(C.CBCharacteristic_inst_Properties(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCharacteristic_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCharacteristic_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBCharacteristic_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBCharacteristic_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBCharacteristic_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) IsEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsProxy() bool { - ret := (C.CBCharacteristic_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBCharacteristic_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) DoesContain(object NSObject) bool { - ret := (C.CBCharacteristic_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBCharacteristic_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) DoesNotRecognizeSelector(aSelector SEL) { - C.CBCharacteristic_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ScriptingContains(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Service() *CBService { - ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Service(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBService) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBCharacteristic_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCharacteristic_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCharacteristic_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCharacteristic_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCharacteristic_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCharacteristic_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.CBCharacteristic_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Retain() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Release() { - C.CBCharacteristic_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) WillChangeValueForKey(key *NSString) { - C.CBCharacteristic_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) IsLessThan(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsLike(object *NSString) bool { - ret := (C.CBCharacteristic_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Hash() NSUInteger { - ret := (NSUInteger)(C.CBCharacteristic_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCharacteristic_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) RetainCount() NSUInteger { - ret := (NSUInteger)(C.CBCharacteristic_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsNotEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCharacteristic_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBCharacteristic_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) IsGreaterThan(object NSObject) bool { - ret := (C.CBCharacteristic_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ForwardInvocation(anInvocation *NSInvocation) { - C.CBCharacteristic_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) IsNotifying() bool { - ret := (C.CBCharacteristic_inst_IsNotifying(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) Self() *CBCharacteristic { - ret := &CBCharacteristic{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBCharacteristic) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) SetNilValueForKey(key *NSString) { - C.CBCharacteristic_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.CBCharacteristic_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCharacteristic_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCharacteristic_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBCharacteristic_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBCharacteristic) SetValueForKey(value NSObject, key *NSString) { - C.CBCharacteristic_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBCharacteristic_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBCharacteristic) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBCharacteristic_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func NSAutoreleasePoolAllocWithZone(zone *_NSZone) *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - return ret -} - -func NSAutoreleasePoolCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSAutoreleasePoolResolveClassMethod(sel SEL) bool { - ret := (C.NSAutoreleasePool_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSAutoreleasePoolIsSubclassOfClass(aClass Class) bool { - ret := (C.NSAutoreleasePool_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSAutoreleasePoolInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSAutoreleasePoolKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSAutoreleasePoolAddObject(anObject NSObject) { - C.NSAutoreleasePool_AddObject(anObject.Ptr()) -} - -func NSAutoreleasePoolMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSAutoreleasePoolSetVersion(aVersion NSInteger) { - C.NSAutoreleasePool_SetVersion((C.NSInteger)(aVersion)) -} - -func NSAutoreleasePoolClass() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Class())) - return ret -} - -func NSAutoreleasePoolVersion() NSInteger { - ret := (NSInteger)(C.NSAutoreleasePool_Version()) - return ret -} - -func NSAutoreleasePoolNew() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - return ret -} - -func NSAutoreleasePoolAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSAutoreleasePool_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSAutoreleasePoolAlloc() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - return ret -} - -func (o *NSAutoreleasePool) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSAutoreleasePool) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSAutoreleasePoolResolveInstanceMethod(sel SEL) bool { - ret := (C.NSAutoreleasePool_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSAutoreleasePoolClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSAutoreleasePoolDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSAutoreleasePoolInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSAutoreleasePool_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSAutoreleasePoolAccessInstanceVariablesDirectly() bool { - ret := (C.NSAutoreleasePool_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSAutoreleasePoolHash() NSUInteger { - ret := (NSUInteger)(C.NSAutoreleasePool_Hash()) - return ret -} - -func NSAutoreleasePoolConformsToProtocol(protocol Protocol) bool { - ret := (C.NSAutoreleasePool_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSAutoreleasePoolDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSAutoreleasePoolClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_ClassForKeyedUnarchiver())) - return ret -} - -func NSAutoreleasePoolSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Superclass())) - return ret -} - -func NSAutoreleasePoolCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSAutoreleasePoolLoad() { - C.NSAutoreleasePool_Load() -} - -func (o *NSAutoreleasePool) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSAutoreleasePool_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSAutoreleasePool_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSAutoreleasePool_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsNotEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) RetainCount() NSUInteger { - ret := (NSUInteger)(C.NSAutoreleasePool_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSAutoreleasePool_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSAutoreleasePool_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.NSAutoreleasePool_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsGreaterThan(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsLike(object *NSString) bool { - ret := (C.NSAutoreleasePool_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSAutoreleasePool_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSAutoreleasePool_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ScriptingContains(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ForwardInvocation(anInvocation *NSInvocation) { - C.NSAutoreleasePool_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsEqual(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) AddObject(anObject NSObject) { - C.NSAutoreleasePool_inst_AddObject(o.Ptr(), anObject.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Hash() NSUInteger { - ret := (NSUInteger)(C.NSAutoreleasePool_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) DidChangeValueForKey(key *NSString) { - C.NSAutoreleasePool_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Self() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSAutoreleasePool_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSAutoreleasePool_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSAutoreleasePool_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSAutoreleasePool_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) Drain() { - C.NSAutoreleasePool_inst_Drain(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsKindOfClass(aClass Class) bool { - ret := (C.NSAutoreleasePool_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) DoesNotRecognizeSelector(aSelector SEL) { - C.NSAutoreleasePool_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSAutoreleasePool_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSAutoreleasePool_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) IsLessThan(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Autorelease() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Init() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSAutoreleasePool_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) DoesContain(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) SetNilValueForKey(key *NSString) { - C.NSAutoreleasePool_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) Retain() *NSAutoreleasePool { - ret := &NSAutoreleasePool{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Dealloc() { - C.NSAutoreleasePool_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) RespondsToSelector(aSelector SEL) bool { - ret := (C.NSAutoreleasePool_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSAutoreleasePool_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSAutoreleasePool_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSAutoreleasePool_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSAutoreleasePool_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) IsProxy() bool { - ret := (C.NSAutoreleasePool_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) IsMemberOfClass(aClass Class) bool { - ret := (C.NSAutoreleasePool_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) Release() { - C.NSAutoreleasePool_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) WillChangeValueForKey(key *NSString) { - C.NSAutoreleasePool_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) IsEqualTo(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) SetValueForKey(value NSObject, key *NSString) { - C.NSAutoreleasePool_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSAutoreleasePool_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSAutoreleasePool_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.NSAutoreleasePool_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSAutoreleasePool) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSAutoreleasePool_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSAutoreleasePool) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSAutoreleasePool_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func NSNumberAllocWithZone(zone *_NSZone) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberIsSubclassOfClass(aClass Class) bool { - ret := (C.NSNumber_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSNumberAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSNumber_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSNumberHash() NSUInteger { - ret := (NSUInteger)(C.NSNumber_Hash()) - return ret -} - -func NSNumberWithUnsignedChar(value UnsignedChar) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedChar((C.uchar)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberValueWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithBytesObjCType(unsafe.Pointer(value), unsafe.Pointer(type_))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberValueWithEdgeInsets(insets NSEdgeInsets) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithEdgeInsets((C.NSEdgeInsets)(insets))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberConformsToProtocol(protocol Protocol) bool { - ret := (C.NSNumber_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSNumberSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_Superclass())) - return ret -} - -func NSNumberCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSNumber_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSNumberCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSNumber_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSNumberCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSNumber_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSNumberWithBool(value BOOL) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithBool((C.BOOL)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberValueWithSize(size NSSize) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithSize((C.NSSize)(size))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberValueWithRange(range_ NSRange) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRange((C.NSRange)(range_))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberValueWithNonretainedObject(anObject NSObject) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithNonretainedObject(anObject.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberNew() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithUnsignedShort(value UnsignedShort) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedShort((C.ushort)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithDouble(value Double) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithDouble((C.double)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberValueWithRect(rect NSRect) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRect((C.NSRect)(rect))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSNumberKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSNumber_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_DebugDescription()) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberWithShort(value Short) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithShort((C.short)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithInt(value Int) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInt((C.int)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSNumberClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_ClassForKeyedUnarchiver())) - return ret -} - -func NSNumberClass() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_Class())) - return ret -} - -func NSNumberValueWithPointer(pointer unsafe.Pointer) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPointer(unsafe.Pointer(pointer))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberValueWithPoint(point NSPoint) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPoint((C.NSPoint)(point))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberWithUnsignedInt(value UnsignedInt) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInt((C.uint)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberAlloc() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func (o *NSNumber) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSNumberResolveClassMethod(sel SEL) bool { - ret := (C.NSNumber_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSNumberWithLongLong(value LongLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLongLong((C.longlong)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithUnsignedLongLong(value UnsignedLongLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLongLong((C.ulonglong)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithInteger(value NSInteger) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInteger((C.NSInteger)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithFloat(value Float) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithFloat((C.float)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithChar(value Char) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithChar((C.char)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberSetVersion(aVersion NSInteger) { - C.NSNumber_SetVersion((C.NSInteger)(aVersion)) -} - -func NSNumberInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSNumber_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSNumberResolveInstanceMethod(sel SEL) bool { - ret := (C.NSNumber_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSNumberWithUnsignedInteger(value NSUInteger) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInteger((C.NSUInteger)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberWithUnsignedLong(value UnsignedLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLong((C.ulong)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSNumber_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSNumberAccessInstanceVariablesDirectly() bool { - ret := (C.NSNumber_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func NSNumberVersion() NSInteger { - ret := (NSInteger)(C.NSNumber_Version()) - return ret -} - -func NSNumberLoad() { - C.NSNumber_Load() -} - -func NSNumberWithLong(value Long) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLong((C.long)(value))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - return ret -} - -func NSNumberValueWithObjCType(value unsafe.Pointer, type_ *Char) *NSValue { - ret := &NSValue{} - ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithObjCType(unsafe.Pointer(value), unsafe.Pointer(type_))) - if ret.ptr == nil { return ret } - return ret -} - -func (o *NSNumber) LongValue() Long { - ret := (Long)(C.NSNumber_inst_LongValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithInt(value Int) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInt(o.Ptr(), (C.int)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSNumber_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSNumber_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSNumber_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSNumber_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSNumber_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSNumber_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) IsNotEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSNumber_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InitWithUnsignedShort(value UnsignedShort) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedShort(o.Ptr(), (C.ushort)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Compare(otherNumber *NSNumber) NSComparisonResult { - ret := (NSComparisonResult)(C.NSNumber_inst_Compare(o.Ptr(), otherNumber.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBytesObjCType(o.Ptr(), unsafe.Pointer(value), unsafe.Pointer(type_))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) SetNilValueForKey(key *NSString) { - C.NSNumber_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) DoesNotRecognizeSelector(aSelector SEL) { - C.NSNumber_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSNumber_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) BoolValue() bool { - ret := (C.NSNumber_inst_BoolValue(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DidChangeValueForKey(key *NSString) { - C.NSNumber_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSNumber_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSNumber_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSNumber_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSNumber_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InitWithLongLong(value LongLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLongLong(o.Ptr(), (C.longlong)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DoubleValue() Double { - ret := (Double)(C.NSNumber_inst_DoubleValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithChar(value Char) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithChar(o.Ptr(), (C.char)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsKindOfClass(aClass Class) bool { - ret := (C.NSNumber_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) LongLongValue() LongLong { - ret := (LongLong)(C.NSNumber_inst_LongLongValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Self() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSNumber_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InitWithInteger(value NSInteger) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInteger(o.Ptr(), (C.NSInteger)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) GetValue(value unsafe.Pointer) { - C.NSNumber_inst_GetValue(o.Ptr(), unsafe.Pointer(value)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) GetValueSize(value unsafe.Pointer, size NSUInteger) { - C.NSNumber_inst_GetValueSize(o.Ptr(), unsafe.Pointer(value), (C.NSUInteger)(size)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithFloat(value Float) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithFloat(o.Ptr(), (C.float)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithShort(value Short) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithShort(o.Ptr(), (C.short)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Release() { - C.NSNumber_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IntValue() Int { - ret := (Int)(C.NSNumber_inst_IntValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -/*func (o *NSNumber) DecimalValue() NSDecimal { - ret := (NSDecimal)(C.NSNumber_inst_DecimalValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -}*/ - -func (o *NSNumber) InitWithUnsignedInteger(value NSUInteger) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInteger(o.Ptr(), (C.NSUInteger)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsEqual(object NSObject) bool { - ret := (C.NSNumber_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSNumber_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InitWithBool(value BOOL) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBool(o.Ptr(), (C.BOOL)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) NonretainedObjectValue() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_NonretainedObjectValue(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ForwardInvocation(anInvocation *NSInvocation) { - C.NSNumber_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) StringValue() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_StringValue(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) WillChangeValueForKey(key *NSString) { - C.NSNumber_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSNumber_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSNumber_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingContains(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSNumber_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSNumber_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSNumber_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) Init() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithDouble(value Double) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithDouble(o.Ptr(), (C.double)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) FloatValue() Float { - ret := (Float)(C.NSNumber_inst_FloatValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ShortValue() Short { - ret := (Short)(C.NSNumber_inst_ShortValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSNumber_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSNumber_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSNumber_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) InitWithUnsignedLong(value UnsignedLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLong(o.Ptr(), (C.ulong)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) RangeValue() NSRange { - ret := (NSRange)(C.NSNumber_inst_RangeValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) RespondsToSelector(aSelector SEL) bool { - ret := (C.NSNumber_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PointValue() NSPoint { - ret := (NSPoint)(C.NSNumber_inst_PointValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSNumber_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSNumber_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IntegerValue() NSInteger { - ret := (NSInteger)(C.NSNumber_inst_IntegerValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsEqualToValue(value *NSValue) bool { - ret := (C.NSNumber_inst_IsEqualToValue(o.Ptr(), value.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsLike(object *NSString) bool { - ret := (C.NSNumber_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsGreaterThan(object NSObject) bool { - ret := (C.NSNumber_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ObjCType() *Char { - ret := (*Char)(unsafe.Pointer(C.NSNumber_inst_ObjCType(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsMemberOfClass(aClass Class) bool { - ret := (C.NSNumber_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) UnsignedCharValue() UnsignedChar { - ret := (UnsignedChar)(C.NSNumber_inst_UnsignedCharValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) UnsignedIntValue() UnsignedInt { - ret := (UnsignedInt)(C.NSNumber_inst_UnsignedIntValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Retain() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithCoder(aDecoder *NSCoder) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) SizeValue() NSSize { - ret := (NSSize)(C.NSNumber_inst_SizeValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) RectValue() NSRect { - ret := (NSRect)(C.NSNumber_inst_RectValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithUnsignedInt(value UnsignedInt) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInt(o.Ptr(), (C.uint)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) CharValue() Char { - ret := (Char)(C.NSNumber_inst_CharValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsEqualToNumber(number *NSNumber) bool { - ret := (C.NSNumber_inst_IsEqualToNumber(o.Ptr(), number.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithUnsignedChar(value UnsignedChar) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedChar(o.Ptr(), (C.uchar)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) UnsignedLongLongValue() UnsignedLongLong { - ret := (UnsignedLongLong)(C.NSNumber_inst_UnsignedLongLongValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSNumber_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DoesContain(object NSObject) bool { - ret := (C.NSNumber_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) UnsignedLongValue() UnsignedLong { - ret := (UnsignedLong)(C.NSNumber_inst_UnsignedLongValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSNumber_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.NSNumber_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) RetainCount() NSUInteger { - ret := (NSUInteger)(C.NSNumber_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithLong(value Long) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLong(o.Ptr(), (C.long)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) InitWithUnsignedLongLong(value UnsignedLongLong) *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLongLong(o.Ptr(), (C.ulonglong)(value))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) IsProxy() bool { - ret := (C.NSNumber_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) DescriptionWithLocale(locale NSObject) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) UnsignedIntegerValue() NSUInteger { - ret := (NSUInteger)(C.NSNumber_inst_UnsignedIntegerValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) SetValueForKey(value NSObject, key *NSString) { - C.NSNumber_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSNumber_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSNumber_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) IsLessThan(object NSObject) bool { - ret := (C.NSNumber_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSNumber_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSNumber_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSNumber_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSNumber_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSNumber_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSNumber_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) UnsignedShortValue() UnsignedShort { - ret := (UnsignedShort)(C.NSNumber_inst_UnsignedShortValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) PointerValue() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_PointerValue(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSNumber_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSNumber_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSNumber) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Autorelease() *NSNumber { - ret := &NSNumber{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSNumber) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Dealloc() { - C.NSNumber_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSNumber) EdgeInsetsValue() NSEdgeInsets { - ret := (NSEdgeInsets)(C.NSNumber_inst_EdgeInsetsValue(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Hash() NSUInteger { - ret := (NSUInteger)(C.NSNumber_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.NSNumber_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSNumber) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func NSUUIDSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_Superclass())) - return ret -} - -func NSUUIDAlloc() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_Alloc()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - return ret -} - -func (o *NSUUID) GC() { - if o.ptr == nil { return } - runtime.SetFinalizer(o, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) -} - -func NSUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } - return ret -} - -func NSUUIDClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_ClassFallbacksForKeyedArchiver()) - if ret.ptr == nil { return ret } - return ret -} - -func NSUUIDSupportsSecureCoding() bool { - ret := (C.NSUUID_SupportsSecureCoding()) != 0 - return ret -} - -func NSUUIDCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSUUIDClass() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_Class())) - return ret -} - -func NSUUIDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_DebugDescription()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSUUIDHash() NSUInteger { - ret := (NSUInteger)(C.NSUUID_Hash()) - return ret -} - -func NSUUIDLoad() { - C.NSUUID_Load() -} - -func NSUUIDClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_ClassForKeyedUnarchiver())) - return ret -} - -func NSUUIDAllocWithZone(zone *_NSZone) *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - return ret -} - -func NSUUIDConformsToProtocol(protocol Protocol) bool { - ret := (C.NSUUID_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func NSUUIDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_Description()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - return ret -} - -func NSUUIDNew() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_New()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - return ret -} - -func NSUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.NSUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } - return ret -} - -func NSUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.NSUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func NSUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.NSUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func NSUUIDResolveInstanceMethod(sel SEL) bool { - ret := (C.NSUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSUUIDInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.NSUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 - return ret -} - -func NSUUIDResolveClassMethod(sel SEL) bool { - ret := (C.NSUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0 - return ret -} - -func NSUUIDIsSubclassOfClass(aClass Class) bool { - ret := (C.NSUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func NSUUIDVersion() NSInteger { - ret := (NSInteger)(C.NSUUID_Version()) - return ret -} - -func NSUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.NSUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 - return ret -} - -func NSUUIDUUID() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_UUID()) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - return ret -} - -func NSUUIDMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func NSUUIDSetVersion(aVersion NSInteger) { - C.NSUUID_SetVersion((C.NSInteger)(aVersion)) -} - -func NSUUIDAccessInstanceVariablesDirectly() bool { - ret := (C.NSUUID_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func (o *NSUUID) InitWithUUIDString(string *NSString) *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDString(o.Ptr(), string.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsMemberOfClass(aClass Class) bool { - ret := (C.NSUUID_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.NSUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Copy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.NSUUID_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsGreaterThan(object NSObject) bool { - ret := (C.NSUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.NSUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) DidChangeValueForKey(key *NSString) { - C.NSUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { - - goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) - for i := 0; i < len(*ioValue); i++ { - goSlice1[i] = (*ioValue)[i].Ptr() - } - - goSlice3 := make([]unsafe.Pointer,cap(*outError)) - for i := 0; i < len(*outError); i++ { - goSlice3[i] = (*outError)[i].Ptr() - } - ret := (C.NSUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 - (*ioValue) = (*ioValue)[:cap(*ioValue)] - for i := 0; i < len(*ioValue); i++ { - if goSlice1[i] == nil { - (*ioValue) = (*ioValue)[:i] - break - } - if (*ioValue)[i] == nil { - (*ioValue)[i] = &Id{} - runtime.SetFinalizer((*ioValue)[i], func(o *Id) { - o.Release() - }) - } - (*ioValue)[i].ptr = goSlice1[i] - } - (*outError) = (*outError)[:cap(*outError)] - for i := 0; i < len(*outError); i++ { - if goSlice3[i] == nil { - (*outError) = (*outError)[:i] - break - } - if (*outError)[i] == nil { - (*outError)[i] = &NSError{} - runtime.SetFinalizer((*outError)[i], func(o *NSError) { - o.Release() - }) - } - (*outError)[i].ptr = goSlice3[i] - } - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsLessThan(object NSObject) bool { - ret := (C.NSUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.NSUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) SetNilValueForKey(key *NSString) { - C.NSUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.NSUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) Self() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) RespondsToSelector(aSelector SEL) bool { - ret := (C.NSUUID_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Init() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Init(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingEndsWith(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingContains(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.NSUUID_inst_Zone(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.NSUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ForwardInvocation(anInvocation *NSInvocation) { - C.NSUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ScriptingIsLessThan(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.NSUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingBeginsWith(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.NSUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.NSUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.NSUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) GetUUIDBytes(uuid *UnsignedChar) { - C.NSUUID_inst_GetUUIDBytes(o.Ptr(), unsafe.Pointer(uuid)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) IsEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) SetValueForKey(value NSObject, key *NSString) { - C.NSUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.NSUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.NSUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) IsKindOfClass(aClass Class) bool { - ret := (C.NSUUID_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Dealloc() { - C.NSUUID_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.NSUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.NSUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.NSUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.NSUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) IsProxy() bool { - ret := (C.NSUUID_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Hash() NSUInteger { - ret := (NSUInteger)(C.NSUUID_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Retain() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) DoesContain(object NSObject) bool { - ret := (C.NSUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.NSUUID_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) UUIDString() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_UUIDString(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) WillChangeValueForKey(key *NSString) { - C.NSUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.NSUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ToManyRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToManyRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsEqual(object NSObject) bool { - ret := (C.NSUUID_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsNotEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Autorelease() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) CopyWithZone(zone *NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.NSUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) SetObservationInfo(observationInfo unsafe.Pointer) { - C.NSUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.NSUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.NSUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) DoesNotRecognizeSelector(aSelector SEL) { - C.NSUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *NSUUID) Release() { - C.NSUUID_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *NSUUID) RetainCount() NSUInteger { - ret := (NSUInteger)(C.NSUUID_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) InitWithUUIDBytes(bytes *UnsignedChar) *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDBytes(o.Ptr(), unsafe.Pointer(bytes))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.NSUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.NSUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.NSUUID_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *NSUUID) IsLike(object *NSString) bool { - ret := (C.NSUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) return ret } -func (o *NSUUID) ClassCode() FourCharCode { - ret := (FourCharCode)(C.NSUUID_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) +func CBPeripheralClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheral_ClassForKeyedUnarchiver())) return ret } @@ -58657,46 +30178,18 @@ func CBPeripheralCopyWithZone(zone *_NSZone) *Id { return ret } -func CBPeripheralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) +func CBPeripheralAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBPeripheral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBPeripheralNew() *CBPeripheral { + ret := &CBPeripheral{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_New()) if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralAccessInstanceVariablesDirectly() bool { - ret := (C.CBPeripheral_AccessInstanceVariablesDirectly()) != 0 - return ret -} - -func CBPeripheralIsSubclassOfClass(aClass Class) bool { - ret := (C.CBPeripheral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 - return ret -} - -func CBPeripheralVersion() NSInteger { - ret := (NSInteger)(C.CBPeripheral_Version()) - return ret -} - -func CBPeripheralLoad() { - C.CBPeripheral_Load() -} - -func CBPeripheralConformsToProtocol(protocol Protocol) bool { - ret := (C.CBPeripheral_ConformsToProtocol(protocol.Ptr())) != 0 - return ret -} - -func CBPeripheralDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_Description()) - if ret.ptr == nil { return ret } - return ret -} - -func CBPeripheralSuperclass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_Superclass())) + runtime.SetFinalizer(ret, func(o *CBPeripheral) { + o.Release() + }) return ret } @@ -58705,53 +30198,21 @@ func CBPeripheralResolveClassMethod(sel SEL) bool { return ret } -func CBPeripheralAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBPeripheral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 +func CBPeripheralInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBPeripheral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 return ret } -func CBPeripheralMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBPeripheralAllocWithZone(zone *_NSZone) *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_AllocWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { - o.Release() - }) - return ret -} - -func CBPeripheralClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_ClassForKeyedUnarchiver())) - return ret -} - -func CBPeripheralClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_ClassFallbacksForKeyedArchiver()) +func CBPeripheralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) if ret.ptr == nil { return ret } return ret } -func CBPeripheralCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBPeripheral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBPeripheralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBPeripheralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +func CBPeripheralHash() NSUInteger { + ret := (NSUInteger)(C.CBPeripheral_Hash()) + return ret } func CBPeripheralDebugDescription() *NSString { @@ -58765,13 +30226,23 @@ func CBPeripheralSetVersion(aVersion NSInteger) { C.CBPeripheral_SetVersion((C.NSInteger)(aVersion)) } +func CBPeripheralSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheral_Superclass())) + return ret +} + +func CBPeripheralIsSubclassOfClass(aClass Class) bool { + ret := (C.CBPeripheral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + func CBPeripheralClass() Class { ret := (Class)(unsafe.Pointer(C.CBPeripheral_Class())) return ret } -func CBPeripheralInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBPeripheral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 +func CBPeripheralConformsToProtocol(protocol Protocol) bool { + ret := (C.CBPeripheral_ConformsToProtocol(protocol.Ptr())) != 0 return ret } @@ -58782,6 +30253,37 @@ func CBPeripheralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { return ret } +func CBPeripheralAccessInstanceVariablesDirectly() bool { + ret := (C.CBPeripheral_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBPeripheralLoad() { + C.CBPeripheral_Load() +} + +func CBPeripheralMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBPeripheralCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBPeripheral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBPeripheralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBPeripheralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + func CBPeripheralAlloc() *CBPeripheral { ret := &CBPeripheral{} ret.ptr = unsafe.Pointer(C.CBPeripheral_Alloc()) @@ -58800,13 +30302,10 @@ func (o *CBPeripheral) GC() { runtime.KeepAlive(o) } -func CBPeripheralNew() *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_New()) +func CBPeripheralClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_ClassFallbacksForKeyedArchiver()) if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { - o.Release() - }) return ret } @@ -58815,178 +30314,34 @@ func CBPeripheralResolveInstanceMethod(sel SEL) bool { return ret } -func CBPeripheralHash() NSUInteger { - ret := (NSUInteger)(C.CBPeripheral_Hash()) +func CBPeripheralVersion() NSInteger { + ret := (NSInteger)(C.CBPeripheral_Version()) return ret } -func (o *CBPeripheral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) +func (o *CBPeripheral) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ToOneRelationshipKeys(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) +func (o *CBPeripheral) ForwardInvocation(anInvocation *NSInvocation) { + C.CBPeripheral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) IsEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) MaximumWriteValueLengthForType(type_ CBCharacteristicWriteType) NSUInteger { - ret := (NSUInteger)(C.CBPeripheral_inst_MaximumWriteValueLengthForType(o.Ptr(), (C.CBCharacteristicWriteType)(type_))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBPeripheral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBPeripheral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) DiscoverDescriptorsForCharacteristic(characteristic *CBCharacteristic) { - C.CBPeripheral_inst_DiscoverDescriptorsForCharacteristic(o.Ptr(), characteristic.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { o.Release() }) runtime.KeepAlive(o) @@ -59005,192 +30360,9 @@ func (o *CBPeripheral) ForwardingTargetForSelector(aSelector SEL) *Id { return ret } -func (o *CBPeripheral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ScriptingIsLessThan(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBPeripheral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBPeripheral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBPeripheral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) RetainCount() NSUInteger { - ret := (NSUInteger)(C.CBPeripheral_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBPeripheral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) IsKindOfClass(aClass Class) bool { - ret := (C.CBPeripheral_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) InsertValueInPropertyWithKey(value NSObject, key *NSString) { - C.CBPeripheral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { - C.CBPeripheral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { - C.CBPeripheral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) SetNilValueForKey(key *NSString) { - C.CBPeripheral_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBPeripheral_inst_ClassCode(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ClassName() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassName(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.CBPeripheral_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBPeripheral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Delegate() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Delegate(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBPeripheral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBPeripheral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBPeripheral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBPeripheral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Dealloc() { - C.CBPeripheral_inst_Dealloc(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Services() *NSArray { +func (o *CBPeripheral) AttributeKeys() *NSArray { ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Services(o.Ptr())) + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AttributeKeys(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *NSArray) { @@ -59200,119 +30372,24 @@ func (o *CBPeripheral) Services() *NSArray { return ret } -func (o *CBPeripheral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) +func (o *CBPeripheral) State() CBPeripheralState { + ret := (CBPeripheralState)(C.CBPeripheral_inst_State(o.Ptr())) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) SetValueForKey(value NSObject, key *NSString) { - C.CBPeripheral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) +func (o *CBPeripheral) WriteValueForDescriptor(data *NSData, descriptor *CBDescriptor) { + C.CBPeripheral_inst_WriteValueForDescriptor(o.Ptr(), data.Ptr(), descriptor.Ptr()) runtime.KeepAlive(o) } -func (o *CBPeripheral) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBPeripheral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) +func (o *CBPeripheral) WriteValueForCharacteristic(data *NSData, characteristic *CBCharacteristic, type_ CBCharacteristicWriteType) { + C.CBPeripheral_inst_WriteValueForCharacteristic(o.Ptr(), data.Ptr(), characteristic.Ptr(), (C.CBCharacteristicWriteType)(type_)) runtime.KeepAlive(o) } -func (o *CBPeripheral) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBPeripheral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) MutableSetValueForKey(key *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ScriptingContains(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) DidChangeValueForKey(key *NSString) { - C.CBPeripheral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) IsMemberOfClass(aClass Class) bool { - ret := (C.CBPeripheral_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) +func (o *CBPeripheral) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } @@ -59329,80 +30406,6 @@ func (o *CBPeripheral) ToManyRelationshipKeys() *NSArray { return ret } -func (o *CBPeripheral) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) SetDelegate(delegate NSObject) { - C.CBPeripheral_inst_SetDelegate(o.Ptr(), delegate.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ClassForCoder() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForCoder(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) CanSendWriteWithoutResponse() bool { - ret := (C.CBPeripheral_inst_CanSendWriteWithoutResponse(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) SetNotifyValue(enabled BOOL, characteristic *CBCharacteristic) { - C.CBPeripheral_inst_SetNotifyValue(o.Ptr(), (C.BOOL)(enabled), characteristic.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) IsEqual(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) DiscoverIncludedServices(includedServiceUUIDs *NSArray, service *CBService) { - C.CBPeripheral_inst_DiscoverIncludedServices(o.Ptr(), includedServiceUUIDs.Ptr(), service.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - func (o *CBPeripheral) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { ret := &Id{} ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) @@ -59427,30 +30430,31 @@ func (o *CBPeripheral) NewScriptingObjectOfClassForValueForKeyWithContentsValue( return ret } -func (o *CBPeripheral) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) +func (o *CBPeripheral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBPeripheral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) +func (o *CBPeripheral) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBPeripheral_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) DoesNotRecognizeSelector(aSelector SEL) { + C.CBPeripheral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) runtime.KeepAlive(o) } -func (o *CBPeripheral) WriteValueForDescriptor(data *NSData, descriptor *CBDescriptor) { - C.CBPeripheral_inst_WriteValueForDescriptor(o.Ptr(), data.Ptr(), descriptor.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) WriteValueForCharacteristic(data *NSData, characteristic *CBCharacteristic, type_ CBCharacteristicWriteType) { - C.CBPeripheral_inst_WriteValueForCharacteristic(o.Ptr(), data.Ptr(), characteristic.Ptr(), (C.CBCharacteristicWriteType)(type_)) +func (o *CBPeripheral) ReadRSSI() { + C.CBPeripheral_inst_ReadRSSI(o.Ptr()) runtime.KeepAlive(o) } @@ -59460,21 +30464,54 @@ func (o *CBPeripheral) ScriptingIsEqualTo(object NSObject) bool { return ret } -func (o *CBPeripheral) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForArchiver(o.Ptr()))) +func (o *CBPeripheral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBPeripheral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBPeripheral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) State() CBPeripheralState { - ret := (CBPeripheralState)(C.CBPeripheral_inst_State(o.Ptr())) +func (o *CBPeripheral) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBPeripheral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { +func (o *CBPeripheral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) DiscoverCharacteristics(characteristicUUIDs *NSArray, service *CBService) { + C.CBPeripheral_inst_DiscoverCharacteristics(o.Ptr(), characteristicUUIDs.Ptr(), service.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) AutoContentAccessingProxy() *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AutoContentAccessingProxy(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -59484,59 +30521,32 @@ func (o *CBPeripheral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiv return ret } -func (o *CBPeripheral) ScriptingBeginsWith(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ReadValueForCharacteristic(characteristic *CBCharacteristic) { - C.CBPeripheral_inst_ReadValueForCharacteristic(o.Ptr(), characteristic.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) +func (o *CBPeripheral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) +func (o *CBPeripheral) IsLessThan(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) Self() *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { - o.Release() - }) +func (o *CBPeripheral) ScriptingContains(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForKeyedArchiver(o.Ptr()))) runtime.KeepAlive(o) return ret } @@ -59553,113 +30563,38 @@ func (o *CBPeripheral) CoerceValueForKey(value NSObject, key *NSString) *Id { return ret } -func (o *CBPeripheral) WillChangeValueForKey(key *NSString) { - C.CBPeripheral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) IsGreaterThan(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 +func (o *CBPeripheral) CanSendWriteWithoutResponse() bool { + ret := (C.CBPeripheral_inst_CanSendWriteWithoutResponse(o.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ScriptingIsGreaterThan(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) Hash() NSUInteger { - ret := (NSUInteger)(C.CBPeripheral_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBPeripheral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBPeripheral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) ForwardInvocation(anInvocation *NSInvocation) { - C.CBPeripheral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Autorelease() *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Autorelease(o.Ptr())) +func (o *CBPeripheral) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) DiscoverCharacteristics(characteristicUUIDs *NSArray, service *CBService) { - C.CBPeripheral_inst_DiscoverCharacteristics(o.Ptr(), characteristicUUIDs.Ptr(), service.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Identifier() *NSUUID { - ret := &NSUUID{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Identifier(o.Ptr())) +func (o *CBPeripheral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSUUID) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) IsNotEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ReadRSSI() { - C.CBPeripheral_inst_ReadRSSI(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) +func (o *CBPeripheral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBPeripheral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) runtime.KeepAlive(o) } @@ -59675,14 +30610,35 @@ func (o *CBPeripheral) ObjectSpecifier() *NSScriptObjectSpecifier { return ret } -func (o *CBPeripheral) Release() { - C.CBPeripheral_inst_Release(o.Ptr()) +func (o *CBPeripheral) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBPeripheral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) runtime.KeepAlive(o) } -func (o *CBPeripheral) ReplacementObjectForCoder(aCoder *NSCoder) *Id { +func (o *CBPeripheral) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBPeripheral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBPeripheral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBPeripheral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -59692,29 +30648,62 @@ func (o *CBPeripheral) ReplacementObjectForCoder(aCoder *NSCoder) *Id { return ret } -func (o *CBPeripheral) IsLessThan(object NSObject) bool { - ret := (C.CBPeripheral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 +func (o *CBPeripheral) IsEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) +func (o *CBPeripheral) IsNotEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) Identifier() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Identifier(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSUUID) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ValueForUndefinedKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) +func (o *CBPeripheral) Services() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Services(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) IsGreaterThan(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableCopy(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { o.Release() }) @@ -59722,32 +30711,45 @@ func (o *CBPeripheral) ValueForUndefinedKey(key *NSString) *Id { return ret } -func (o *CBPeripheral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) +func (o *CBPeripheral) SetNilValueForKey(key *NSString) { + C.CBPeripheral_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBPeripheral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBPeripheral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheral_inst_ObservationInfo(o.Ptr()))) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) DoesContain(object NSObject) bool { - ret := (C.CBPeripheral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 +func (o *CBPeripheral) DiscoverIncludedServices(includedServiceUUIDs *NSArray, service *CBService) { + C.CBPeripheral_inst_DiscoverIncludedServices(o.Ptr(), includedServiceUUIDs.Ptr(), service.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) SetDelegate(delegate NSObject) { + C.CBPeripheral_inst_SetDelegate(o.Ptr(), delegate.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) MaximumWriteValueLengthForType(type_ CBCharacteristicWriteType) NSUInteger { + ret := (NSUInteger)(C.CBPeripheral_inst_MaximumWriteValueLengthForType(o.Ptr(), (C.CBCharacteristicWriteType)(type_))) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) +func (o *CBPeripheral) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } @@ -59928,9 +30930,10 @@ func (o *CBPeripheral) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *N return ret } -func (o *CBPeripheral) ReadValueForDescriptor(descriptor *CBDescriptor) { - C.CBPeripheral_inst_ReadValueForDescriptor(o.Ptr(), descriptor.Ptr()) +func (o *CBPeripheral) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) + return ret } func (o *CBPeripheral) Name() *NSString { @@ -59945,95 +30948,103 @@ func (o *CBPeripheral) Name() *NSString { return ret } -func (o *CBPeripheral) DoesNotRecognizeSelector(aSelector SEL) { - C.CBPeripheral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_Superclass(o.Ptr()))) +func (o *CBPeripheral) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) Copy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Copy(o.Ptr())) +func (o *CBPeripheral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassDescription(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheral_inst_ObservationInfo(o.Ptr()))) +func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) Retain() *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Retain(o.Ptr())) +func (o *CBPeripheral) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) RespondsToSelector(aSelector SEL) bool { - ret := (C.CBPeripheral_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBPeripheral) DiscoverServices(serviceUUIDs *NSArray) { - C.CBPeripheral_inst_DiscoverServices(o.Ptr(), serviceUUIDs.Ptr()) - runtime.KeepAlive(o) -} - func (o *CBPeripheral) ScriptingEndsWith(object NSObject) bool { ret := (C.CBPeripheral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) IsProxy() bool { - ret := (C.CBPeripheral_inst_IsProxy(o.Ptr())) != 0 +func (o *CBPeripheral) DiscoverDescriptorsForCharacteristic(characteristic *CBCharacteristic) { + C.CBPeripheral_inst_DiscoverDescriptorsForCharacteristic(o.Ptr(), characteristic.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForCoder(o.Ptr()))) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBPeripheral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBPeripheral) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.CBPeripheral_inst_Zone(o.Ptr()))) +func (o *CBPeripheral) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForArchiver(o.Ptr()))) runtime.KeepAlive(o) return ret } -func (o *CBPeripheral) ToOneRelationshipKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ToOneRelationshipKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) +func (o *CBPeripheral) SetValueForKey(value NSObject, key *NSString) { + C.CBPeripheral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBPeripheral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBPeripheral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) runtime.KeepAlive(o) - return ret } func (o *CBPeripheral) InverseForRelationshipKey(relationshipKey *NSString) *NSString { @@ -60048,12 +31059,141 @@ func (o *CBPeripheral) InverseForRelationshipKey(relationshipKey *NSString) *NSS return ret } +func (o *CBPeripheral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBPeripheral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBPeripheral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBPeripheral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBPeripheral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + func (o *CBPeripheral) IsLike(object *NSString) bool { ret := (C.CBPeripheral_inst_IsLike(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } +func (o *CBPeripheral) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBPeripheral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + func (o *CBPeripheral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { ret := &NSDictionary{} ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) @@ -60066,38 +31206,216 @@ func (o *CBPeripheral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary return ret } -func (o *CBPeripheral) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 +func (o *CBPeripheral) DiscoverServices(serviceUUIDs *NSArray) { + C.CBPeripheral_inst_DiscoverServices(o.Ptr(), serviceUUIDs.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) runtime.KeepAlive(o) return ret } -func CBServiceIsSubclassOfClass(aClass Class) bool { - ret := (C.CBService_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 +func (o *CBPeripheral) Dealloc() { + C.CBPeripheral_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) return ret } -func CBServiceAccessInstanceVariablesDirectly() bool { - ret := (C.CBService_AccessInstanceVariablesDirectly()) != 0 +func (o *CBPeripheral) DidChangeValueForKey(key *NSString) { + C.CBPeripheral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ReadValueForDescriptor(descriptor *CBDescriptor) { + C.CBPeripheral_inst_ReadValueForDescriptor(o.Ptr(), descriptor.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) return ret } -func CBServiceKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { - ret := &NSSet{} - ret.ptr = unsafe.Pointer(C.CBService_KeyPathsForValuesAffectingValueForKey(key.Ptr())) - if ret.ptr == nil { return ret } +func (o *CBPeripheral) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) return ret } -func CBServiceInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBService_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) - if ret.ptr == nil { return ret } +func (o *CBPeripheral) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) return ret } -func CBServiceInstancesRespondToSelector(aSelector SEL) bool { - ret := (C.CBService_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 +func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) ReadValueForCharacteristic(characteristic *CBCharacteristic) { + C.CBPeripheral_inst_ReadValueForCharacteristic(o.Ptr(), characteristic.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBPeripheral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) Delegate() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Delegate(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBPeripheral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBPeripheral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) DoesContain(object NSObject) bool { + ret := (C.CBPeripheral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) WillChangeValueForKey(key *NSString) { + C.CBPeripheral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheral) SetNotifyValue(enabled BOOL, characteristic *CBCharacteristic) { + C.CBPeripheral_inst_SetNotifyValue(o.Ptr(), (C.BOOL)(enabled), characteristic.Ptr()) + runtime.KeepAlive(o) +} + +func CBServiceClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBService_ClassForKeyedUnarchiver())) + return ret +} + +func CBServiceAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBService_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 return ret } @@ -60106,23 +31424,28 @@ func CBServiceConformsToProtocol(protocol Protocol) bool { return ret } -func CBServiceDebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_DebugDescription()) - if ret.ptr == nil { return ret } +func CBServiceHash() NSUInteger { + ret := (NSUInteger)(C.CBService_Hash()) return ret } -func CBServiceClassFallbacksForKeyedArchiver() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_ClassFallbacksForKeyedArchiver()) +func CBServiceCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_CopyWithZone(unsafe.Pointer(zone))) if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) return ret } -func CBServiceAllocWithZone(zone *_NSZone) *CBService { +func CBServiceLoad() { + C.CBService_Load() +} + +func CBServiceNew() *CBService { ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBService_AllocWithZone(unsafe.Pointer(zone))) + ret.ptr = unsafe.Pointer(C.CBService_New()) if ret.ptr == nil { return ret } runtime.SetFinalizer(ret, func(o *CBService) { o.Release() @@ -60135,25 +31458,25 @@ func CBServiceResolveInstanceMethod(sel SEL) bool { return ret } -func CBServiceCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { - C.CBService_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) -} - -func CBServiceCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBService_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBServiceCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { - C.CBService_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) -} - -func CBServiceAutomaticallyNotifiesObserversForKey(key *NSString) bool { - ret := (C.CBService_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 +func CBServiceResolveClassMethod(sel SEL) bool { + ret := (C.CBService_ResolveClassMethod(unsafe.Pointer(sel))) != 0 return ret } -func CBServiceHash() NSUInteger { - ret := (NSUInteger)(C.CBService_Hash()) +func CBServiceDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBService_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBServiceMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) return ret } @@ -60175,8 +31498,25 @@ func (o *CBService) GC() { runtime.KeepAlive(o) } -func CBServiceClass() Class { - ret := (Class)(unsafe.Pointer(C.CBService_Class())) +func CBServiceClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBService_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBServiceIsSubclassOfClass(aClass Class) bool { + ret := (C.CBService_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBServiceAllocWithZone(zone *_NSZone) *CBService { + ret := &CBService{} + ret.ptr = unsafe.Pointer(C.CBService_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBService) { + o.Release() + }) return ret } @@ -60185,168 +31525,60 @@ func CBServiceSuperclass() Class { return ret } +func CBServiceInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBService_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBServiceCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBService_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBServiceCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBService_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBServiceCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBService_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBServiceDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBService_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + func CBServiceSetVersion(aVersion NSInteger) { C.CBService_SetVersion((C.NSInteger)(aVersion)) } -func CBServiceMutableCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_MutableCopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - -func CBServiceCopyWithZone(zone *_NSZone) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_CopyWithZone(unsafe.Pointer(zone))) - if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - return ret -} - func CBServiceVersion() NSInteger { ret := (NSInteger)(C.CBService_Version()) return ret } -func CBServiceDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_Description()) +func CBServiceKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBService_KeyPathsForValuesAffectingValueForKey(key.Ptr())) if ret.ptr == nil { return ret } return ret } -func CBServiceLoad() { - C.CBService_Load() -} - -func CBServiceResolveClassMethod(sel SEL) bool { - ret := (C.CBService_ResolveClassMethod(unsafe.Pointer(sel))) != 0 +func CBServiceAccessInstanceVariablesDirectly() bool { + ret := (C.CBService_AccessInstanceVariablesDirectly()) != 0 return ret } -func CBServiceNew() *CBService { - ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBService_New()) +func CBServiceInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBService_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) if ret.ptr == nil { return ret } - runtime.SetFinalizer(ret, func(o *CBService) { - o.Release() - }) return ret } -func CBServiceClassForKeyedUnarchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBService_ClassForKeyedUnarchiver())) - return ret -} - -func (o *CBService) RetainCount() NSUInteger { - ret := (NSUInteger)(C.CBService_inst_RetainCount(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsGreaterThan(object NSObject) bool { - ret := (C.CBService_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ClassForArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) WillChangeValueForKey(key *NSString) { - C.CBService_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBService_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBService_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBService_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ObservationInfo() unsafe.Pointer { - ret := (unsafe.Pointer)(unsafe.Pointer(C.CBService_inst_ObservationInfo(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsEqual(object NSObject) bool { - ret := (C.CBService_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ObjectSpecifier() *NSScriptObjectSpecifier { - ret := &NSScriptObjectSpecifier{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ObjectSpecifier(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { - o.Release() - }) - runtime.KeepAlive(o) +func CBServiceClass() Class { + ret := (Class)(unsafe.Pointer(C.CBService_Class())) return ret } @@ -60356,9 +31588,9 @@ func (o *CBService) ClassForCoder() Class { return ret } -func (o *CBService) ToOneRelationshipKeys() *NSArray { +func (o *CBService) IncludedServices() *NSArray { ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ToOneRelationshipKeys(o.Ptr())) + ret.ptr = unsafe.Pointer(C.CBService_inst_IncludedServices(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *NSArray) { @@ -60368,149 +31600,12 @@ func (o *CBService) ToOneRelationshipKeys() *NSArray { return ret } -func (o *CBService) RespondsToSelector(aSelector SEL) bool { - ret := (C.CBService_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 +func (o *CBService) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBService_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBService) Release() { - C.CBService_inst_Release(o.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) Description() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Description(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBService_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBService) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBService_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBService) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { - C.CBService_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBService) DebugDescription() *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_inst_DebugDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AutoContentAccessingProxy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_AutoContentAccessingProxy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ScriptingContains(object NSObject) bool { - ret := (C.CBService_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsPrimary() bool { - ret := (C.CBService_inst_IsPrimary(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ForwardingTargetForSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) Self() *CBService { - ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Self(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBService) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsNotEqualTo(object NSObject) bool { - ret := (C.CBService_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) GetClass() Class { - ret := (Class)(unsafe.Pointer(C.CBService_inst_Class(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ForwardInvocation(anInvocation *NSInvocation) { - C.CBService_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) ScriptingIsEqualTo(object NSObject) bool { - ret := (C.CBService_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) CoerceValueForKey(value NSObject, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { - C.CBService_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { - C.CBService_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) - runtime.KeepAlive(o) -} - func (o *CBService) ToManyRelationshipKeys() *NSArray { ret := &NSArray{} ret.ptr = unsafe.Pointer(C.CBService_inst_ToManyRelationshipKeys(o.Ptr())) @@ -60523,159 +31618,6 @@ func (o *CBService) ToManyRelationshipKeys() *NSArray { return ret } -func (o *CBService) IsCaseInsensitiveLike(object *NSString) bool { - ret := (C.CBService_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ValueForKeyPath(keyPath *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) Superclass() Class { - ret := (Class)(unsafe.Pointer(C.CBService_inst_Superclass(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsEqualTo(object NSObject) bool { - ret := (C.CBService_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) SetNilValueForKey(key *NSString) { - C.CBService_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) ClassDescription() *NSClassDescription { - ret := &NSClassDescription{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ClassDescription(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSClassDescription) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { - C.CBService_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { - C.CBService_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBService) Autorelease() *CBService { - ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Autorelease(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBService) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IsLike(object *NSString) bool { - ret := (C.CBService_inst_IsLike(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { - ret := &NSMutableOrderedSet{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ValueForKey(key *NSString) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) Characteristics() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Characteristics(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBService_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - func (o *CBService) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { ret := &Id{} ret.ptr = unsafe.Pointer(C.CBService_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) @@ -60700,9 +31642,9 @@ func (o *CBService) NewScriptingObjectOfClassForValueForKeyWithContentsValue(obj return ret } -func (o *CBService) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { +func (o *CBService) AutoContentAccessingProxy() *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + ret.ptr = unsafe.Pointer(C.CBService_inst_AutoContentAccessingProxy(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -60712,6 +31654,89 @@ func (o *CBService) NewScriptingObjectOfClassForValueForKeyWithContentsValueProp return ret } +func (o *CBService) ForwardInvocation(anInvocation *NSInvocation) { + C.CBService_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBService_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBService_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBService) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBService_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBService_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBService) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBService_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBService_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + func (o *CBService) Copy() *Id { ret := &Id{} ret.ptr = unsafe.Pointer(C.CBService_inst_Copy(o.Ptr())) @@ -60723,36 +31748,39 @@ func (o *CBService) Copy() *Id { return ret } -func (o *CBService) Hash() NSUInteger { - ret := (NSUInteger)(C.CBService_inst_Hash(o.Ptr())) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ConformsToProtocol(aProtocol Protocol) bool { - ret := (C.CBService_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { - ret := &NSMethodSignature{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) +func (o *CBService) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ObjectSpecifier(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBService) ReplacementObjectForCoder(aCoder *NSCoder) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) +func (o *CBService) DidChangeValueForKey(key *NSString) { + C.CBService_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBService_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBService_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) Characteristics() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBService_inst_Characteristics(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { o.Release() }) runtime.KeepAlive(o) @@ -60935,18 +31963,188 @@ func (o *CBService) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSSt return ret } -func (o *CBService) DidChangeValueForKey(key *NSString) { - C.CBService_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) +func (o *CBService) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IsGreaterThan(object NSObject) bool { + ret := (C.CBService_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBService_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) runtime.KeepAlive(o) } -func (o *CBService) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBService_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) +func (o *CBService) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBService_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBService_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) runtime.KeepAlive(o) } -func (o *CBService) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { - C.CBService_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) +func (o *CBService) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBService_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBService_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBService_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBService_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBService_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) Peripheral() *CBPeripheral { + ret := &CBPeripheral{} + ret.ptr = unsafe.Pointer(C.CBService_inst_Peripheral(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBPeripheral) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBService_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBService_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) IsEqualTo(object NSObject) bool { + ret := (C.CBService_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBService_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IsLike(object *NSString) bool { + ret := (C.CBService_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBService_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBService_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) runtime.KeepAlive(o) } @@ -60962,8 +32160,88 @@ func (o *CBService) ValueForUndefinedKey(key *NSString) *Id { return ret } -func (o *CBService) Zone() *_NSZone { - ret := (*_NSZone)(unsafe.Pointer(C.CBService_inst_Zone(o.Ptr()))) +func (o *CBService) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBService_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBService_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBService_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) SetNilValueForKey(key *NSString) { + C.CBService_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) IsPrimary() bool { + ret := (C.CBService_inst_IsPrimary(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) Dealloc() { + C.CBService_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForArchiver(o.Ptr()))) runtime.KeepAlive(o) return ret } @@ -60974,8 +32252,229 @@ func (o *CBService) ScriptingIsGreaterThan(object NSObject) bool { return ret } -func (o *CBService) ScriptingIsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBService_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 +func (o *CBService) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBService_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBService_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBService) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBService_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBService) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ScriptingContains(object NSObject) bool { + ret := (C.CBService_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) DoesNotRecognizeSelector(aSelector SEL) { + C.CBService_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBService) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBService_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBService) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBService_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBService) SetValueForKey(value NSObject, key *NSString) { + C.CBService_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBService_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBService_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IsLessThan(object NSObject) bool { + ret := (C.CBService_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBService_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBService_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBService_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBService_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBService_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBService_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } @@ -61001,271 +32500,8 @@ func (o *CBService) InsertValueAtIndexInPropertyWithKey(value NSObject, index NS runtime.KeepAlive(o) } -func (o *CBService) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBService_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBService_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) IsLessThanOrEqualTo(object NSObject) bool { - ret := (C.CBService_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) SetValueForKey(value NSObject, key *NSString) { - C.CBService_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) SetValueForKeyPath(value NSObject, keyPath *NSString) { - C.CBService_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) SetValueForUndefinedKey(value NSObject, key *NSString) { - C.CBService_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) IsMemberOfClass(aClass Class) bool { - ret := (C.CBService_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) Peripheral() *CBPeripheral { - ret := &CBPeripheral{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Peripheral(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBPeripheral) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ScriptingProperties() *NSDictionary { - ret := &NSDictionary{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingProperties(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSDictionary) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ScriptingEndsWith(object NSObject) bool { - ret := (C.CBService_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) Retain() *CBService { - ret := &CBService{} - ret.ptr = unsafe.Pointer(C.CBService_inst_Retain(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBService) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) SetObservationInfo(observationInfo unsafe.Pointer) { - C.CBService_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) - runtime.KeepAlive(o) -} - -func (o *CBService) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBService_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { - C.CBService_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) IsGreaterThanOrEqualTo(object NSObject) bool { - ret := (C.CBService_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) PerformSelector(aSelector SEL) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { - C.CBService_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBService_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { - C.CBService_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBService_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { - C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { - C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) IsLessThan(object NSObject) bool { - ret := (C.CBService_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) MutableCopy() *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableCopy(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AttributeKeys() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_AttributeKeys(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) SetScriptingProperties(scriptingProperties *NSDictionary) { - C.CBService_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) MutableArrayValueForKey(key *NSString) *NSMutableArray { - ret := &NSMutableArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) UUID() *CBUUID { - ret := &CBUUID{} - ret.ptr = unsafe.Pointer(C.CBService_inst_UUID(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *CBUUID) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) IncludedServices() *NSArray { - ret := &NSArray{} - ret.ptr = unsafe.Pointer(C.CBService_inst_IncludedServices(o.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSArray) { - o.Release() - }) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { - ret := (C.CBService_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { - C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) - runtime.KeepAlive(o) -} - -func (o *CBService) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { - ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) - if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *Id) { - o.Release() - }) +func (o *CBService) DoesContain(object NSObject) bool { + ret := (C.CBService_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } @@ -61282,28 +32518,33 @@ func (o *CBService) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArr return ret } -func (o *CBService) ClassCode() FourCharCode { - ret := (FourCharCode)(C.CBService_inst_ClassCode(o.Ptr())) +func (o *CBService) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBService_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBService) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { - C.CBService_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) +func (o *CBService) WillChangeValueForKey(key *NSString) { + C.CBService_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) runtime.KeepAlive(o) } -func (o *CBService) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { - C.CBService_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) +func (o *CBService) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBService_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) runtime.KeepAlive(o) } -func (o *CBService) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { - ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) +func (o *CBService) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBService_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBService) UUID() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBService_inst_UUID(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSMutableSet) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBUUID) { o.Release() }) runtime.KeepAlive(o) @@ -61316,41 +32557,251 @@ func (o *CBService) ScriptingBeginsWith(object NSObject) bool { return ret } -func (o *CBService) InverseForRelationshipKey(relationshipKey *NSString) *NSString { - ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) +func (o *CBService) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBService_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ToOneRelationshipKeys(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } - if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } - runtime.SetFinalizer(ret, func(o *NSString) { + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { o.Release() }) runtime.KeepAlive(o) return ret } -func (o *CBService) Dealloc() { - C.CBService_inst_Dealloc(o.Ptr()) +func (o *CBService) IsNotEqualTo(object NSObject) bool { + ret := (C.CBService_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBService) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBService_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBCharacteristicHash() NSUInteger { + ret := (NSUInteger)(C.CBCharacteristic_Hash()) + return ret +} + +func CBCharacteristicCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBCharacteristicAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBCharacteristic_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBCharacteristicResolveInstanceMethod(sel SEL) bool { + ret := (C.CBCharacteristic_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCharacteristicSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Superclass())) + return ret +} + +func CBCharacteristicDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCharacteristicAccessInstanceVariablesDirectly() bool { + ret := (C.CBCharacteristic_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBCharacteristicClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_ClassForKeyedUnarchiver())) + return ret +} + +func CBCharacteristicConformsToProtocol(protocol Protocol) bool { + ret := (C.CBCharacteristic_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBCharacteristicMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBCharacteristicCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBCharacteristic_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCharacteristicAllocWithZone(zone *_NSZone) *CBCharacteristic { + ret := &CBCharacteristic{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCharacteristic) { + o.Release() + }) + return ret +} + +func CBCharacteristicKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBCharacteristicResolveClassMethod(sel SEL) bool { + ret := (C.CBCharacteristic_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCharacteristicAlloc() *CBCharacteristic { + ret := &CBCharacteristic{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCharacteristic) { + o.Release() + }) + return ret +} + +func (o *CBCharacteristic) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBCharacteristic) { + o.Release() + }) runtime.KeepAlive(o) } -func (o *CBService) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBService_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) +func CBCharacteristicIsSubclassOfClass(aClass Class) bool { + ret := (C.CBCharacteristic_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBCharacteristicClass() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Class())) + return ret +} + +func CBCharacteristicLoad() { + C.CBCharacteristic_Load() +} + +func CBCharacteristicSetVersion(aVersion NSInteger) { + C.CBCharacteristic_SetVersion((C.NSInteger)(aVersion)) +} + +func CBCharacteristicClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCharacteristicNew() *CBCharacteristic { + ret := &CBCharacteristic{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCharacteristic) { + o.Release() + }) + return ret +} + +func CBCharacteristicInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBCharacteristic_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBCharacteristicInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBCharacteristicDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCharacteristicVersion() NSInteger { + ret := (NSInteger)(C.CBCharacteristic_Version()) + return ret +} + +func (o *CBCharacteristic) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCharacteristic_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) runtime.KeepAlive(o) } -func (o *CBService) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBService_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) +func (o *CBCharacteristic) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCharacteristic_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) runtime.KeepAlive(o) } -func (o *CBService) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { - C.CBService_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) - runtime.KeepAlive(o) -} - -func (o *CBService) MutableSetValueForKey(key *NSString) *NSMutableSet { +func (o *CBCharacteristic) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { ret := &NSMutableSet{} - ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *NSMutableSet) { @@ -61360,9 +32811,317 @@ func (o *CBService) MutableSetValueForKey(key *NSString) *NSMutableSet { return ret } -func (o *CBService) ClassName() *NSString { +func (o *CBCharacteristic) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) Value() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Value(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) DoesContain(object NSObject) bool { + ret := (C.CBCharacteristic_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) DidChangeValueForKey(key *NSString) { + C.CBCharacteristic_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBCharacteristic_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) SetNilValueForKey(key *NSString) { + C.CBCharacteristic_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) Properties() CBCharacteristicProperties { + ret := (CBCharacteristicProperties)(C.CBCharacteristic_inst_Properties(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBCharacteristic_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCharacteristic_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCharacteristic_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCharacteristic_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCharacteristic_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsLessThan(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBCharacteristic_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBCharacteristic_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ClassName() *NSString { ret := &NSString{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ClassName(o.Ptr())) + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassName(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *NSString) { @@ -61372,9 +33131,14 @@ func (o *CBService) ClassName() *NSString { return ret } -func (o *CBService) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { +func (o *CBCharacteristic) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) AutoContentAccessingProxy() *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AutoContentAccessingProxy(o.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -61384,20 +33148,9 @@ func (o *CBService) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSp return ret } -func (o *CBService) DoesNotRecognizeSelector(aSelector SEL) { - C.CBService_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) - runtime.KeepAlive(o) -} - -func (o *CBService) IsKindOfClass(aClass Class) bool { - ret := (C.CBService_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { +func (o *CBCharacteristic) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -61407,47 +33160,15 @@ func (o *CBService) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { return ret } -func (o *CBService) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { - C.CBService_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { - C.CBService_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { - C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) - runtime.KeepAlive(o) -} - -func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { - C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) - runtime.KeepAlive(o) -} - -func (o *CBService) DoesContain(object NSObject) bool { - ret := (C.CBService_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 +func (o *CBCharacteristic) IsEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 runtime.KeepAlive(o) return ret } -func (o *CBService) IsProxy() bool { - ret := (C.CBService_inst_IsProxy(o.Ptr())) != 0 - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ClassForKeyedArchiver() Class { - ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForKeyedArchiver(o.Ptr()))) - runtime.KeepAlive(o) - return ret -} - -func (o *CBService) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { +func (o *CBCharacteristic) ValueForKey(key *NSString) *Id { ret := &Id{} - ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKey(o.Ptr(), key.Ptr())) if ret.ptr == nil { runtime.KeepAlive(o); return ret } if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } runtime.SetFinalizer(ret, func(o *Id) { @@ -61457,6 +33178,27656 @@ func (o *CBService) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *N return ret } +func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingContains(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBCharacteristic_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCharacteristic_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsNotifying() bool { + ret := (C.CBCharacteristic_inst_IsNotifying(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBCharacteristic_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) IsNotEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) Dealloc() { + C.CBCharacteristic_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBCharacteristic_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCharacteristic_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCharacteristic_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) UUID() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_UUID(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) DoesNotRecognizeSelector(aSelector SEL) { + C.CBCharacteristic_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsGreaterThan(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBCharacteristic_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBCharacteristic_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsLike(object *NSString) bool { + ret := (C.CBCharacteristic_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCharacteristic_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCharacteristic_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCharacteristic_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCharacteristic_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) SetValueForKey(value NSObject, key *NSString) { + C.CBCharacteristic_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBCharacteristic_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBCharacteristic_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBCharacteristic_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBCharacteristic_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBCharacteristic_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCharacteristic_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCharacteristic_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) Descriptors() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Descriptors(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) Service() *CBService { + ret := &CBService{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Service(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBService) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBCharacteristic_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCharacteristic) ForwardInvocation(anInvocation *NSInvocation) { + C.CBCharacteristic_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) WillChangeValueForKey(key *NSString) { + C.CBCharacteristic_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCharacteristic) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBDescriptorInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBDescriptor_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBDescriptorConformsToProtocol(protocol Protocol) bool { + ret := (C.CBDescriptor_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBDescriptorMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBDescriptorClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_ClassForKeyedUnarchiver())) + return ret +} + +func CBDescriptorCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBDescriptorClass() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_Class())) + return ret +} + +func CBDescriptorCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBDescriptor_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBDescriptorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBDescriptorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBDescriptorResolveInstanceMethod(sel SEL) bool { + ret := (C.CBDescriptor_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBDescriptorAllocWithZone(zone *_NSZone) *CBDescriptor { + ret := &CBDescriptor{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBDescriptor) { + o.Release() + }) + return ret +} + +func CBDescriptorAccessInstanceVariablesDirectly() bool { + ret := (C.CBDescriptor_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBDescriptorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBDescriptorVersion() NSInteger { + ret := (NSInteger)(C.CBDescriptor_Version()) + return ret +} + +func CBDescriptorIsSubclassOfClass(aClass Class) bool { + ret := (C.CBDescriptor_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBDescriptorLoad() { + C.CBDescriptor_Load() +} + +func CBDescriptorDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBDescriptorSetVersion(aVersion NSInteger) { + C.CBDescriptor_SetVersion((C.NSInteger)(aVersion)) +} + +func CBDescriptorAlloc() *CBDescriptor { + ret := &CBDescriptor{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBDescriptor) { + o.Release() + }) + return ret +} + +func (o *CBDescriptor) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBDescriptor) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBDescriptorNew() *CBDescriptor { + ret := &CBDescriptor{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBDescriptor) { + o.Release() + }) + return ret +} + +func CBDescriptorSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_Superclass())) + return ret +} + +func CBDescriptorDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBDescriptorHash() NSUInteger { + ret := (NSUInteger)(C.CBDescriptor_Hash()) + return ret +} + +func CBDescriptorClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBDescriptorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBDescriptorResolveClassMethod(sel SEL) bool { + ret := (C.CBDescriptor_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBDescriptorAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBDescriptor_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func (o *CBDescriptor) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBDescriptor_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBDescriptor_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBDescriptor_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBDescriptor_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBDescriptor_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBDescriptor_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBDescriptor_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) WillChangeValueForKey(key *NSString) { + C.CBDescriptor_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) DidChangeValueForKey(key *NSString) { + C.CBDescriptor_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBDescriptor_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBDescriptor_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBDescriptor_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBDescriptor_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) SetValueForKey(value NSObject, key *NSString) { + C.CBDescriptor_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBDescriptor_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBDescriptor_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBDescriptor_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBDescriptor_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ScriptingContains(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) Characteristic() *CBCharacteristic { + ret := &CBCharacteristic{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Characteristic(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCharacteristic) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) UUID() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_UUID(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) DoesContain(object NSObject) bool { + ret := (C.CBDescriptor_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBDescriptor_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBDescriptor_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBDescriptor_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBDescriptor_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) SetNilValueForKey(key *NSString) { + C.CBDescriptor_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBDescriptor_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBDescriptor_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBDescriptor_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBDescriptor_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBDescriptor_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) Dealloc() { + C.CBDescriptor_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsGreaterThan(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) Value() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Value(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsLessThan(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBDescriptor_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ForwardInvocation(anInvocation *NSInvocation) { + C.CBDescriptor_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBDescriptor_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsLike(object *NSString) bool { + ret := (C.CBDescriptor_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBDescriptor_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBDescriptor_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBDescriptor_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBDescriptor_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) DoesNotRecognizeSelector(aSelector SEL) { + C.CBDescriptor_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBDescriptor) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) IsNotEqualTo(object NSObject) bool { + ret := (C.CBDescriptor_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBDescriptor) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBUUIDInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBUUIDHash() NSUInteger { + ret := (NSUInteger)(C.CBUUID_Hash()) + return ret +} + +func CBUUIDClass() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_Class())) + return ret +} + +func CBUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBUUIDClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBUUIDResolveClassMethod(sel SEL) bool { + ret := (C.CBUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBUUIDCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBUUIDVersion() NSInteger { + ret := (NSInteger)(C.CBUUID_Version()) + return ret +} + +func CBUUIDWithNSUUID(theUUID *NSUUID) *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithNSUUID(theUUID.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func CBUUIDWithString(theString *NSString) *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithString(theString.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func CBUUIDWithGoString(theString string) *CBUUID { + theString_chr := CharWithGoString(theString) + defer theString_chr.Free() + ret := CBUUIDWithString(NSStringWithUTF8String(theString_chr)) + return ret +} + +func CBUUIDResolveInstanceMethod(sel SEL) bool { + ret := (C.CBUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBUUIDClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_ClassForKeyedUnarchiver())) + return ret +} + +func CBUUIDNew() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func CBUUIDSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_Superclass())) + return ret +} + +func CBUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBUUIDMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBUUIDAllocWithZone(zone *_NSZone) *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func CBUUIDAccessInstanceVariablesDirectly() bool { + ret := (C.CBUUID_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBUUIDLoad() { + C.CBUUID_Load() +} + +func CBUUIDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBUUID_DebugDescription()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func CBUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBUUIDIsSubclassOfClass(aClass Class) bool { + ret := (C.CBUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBUUIDConformsToProtocol(protocol Protocol) bool { + ret := (C.CBUUID_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBUUIDWithData(theData *NSData) *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithData(theData.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func CBUUIDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBUUID_Description()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func CBUUIDSetVersion(aVersion NSInteger) { + C.CBUUID_SetVersion((C.NSInteger)(aVersion)) +} + +func CBUUIDAlloc() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + return ret +} + +func (o *CBUUID) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBUUID) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) DidChangeValueForKey(key *NSString) { + C.CBUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) DoesContain(object NSObject) bool { + ret := (C.CBUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) Data() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_Data(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) WillChangeValueForKey(key *NSString) { + C.CBUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ForwardInvocation(anInvocation *NSInvocation) { + C.CBUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBUUID_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) Dealloc() { + C.CBUUID_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) UUIDString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_UUIDString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) Init() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsLike(object *NSString) bool { + ret := (C.CBUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsGreaterThan(object NSObject) bool { + ret := (C.CBUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) DoesNotRecognizeSelector(aSelector SEL) { + C.CBUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBUUID_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBUUID) SetValueForKey(value NSObject, key *NSString) { + C.CBUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) IsNotEqualTo(object NSObject) bool { + ret := (C.CBUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) SetNilValueForKey(key *NSString) { + C.CBUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBUUID) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBUUID_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) IsLessThan(object NSObject) bool { + ret := (C.CBUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBUUID) ScriptingContains(object NSObject) bool { + ret := (C.CBUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func NSAutoreleasePoolDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSAutoreleasePoolSetVersion(aVersion NSInteger) { + C.NSAutoreleasePool_SetVersion((C.NSInteger)(aVersion)) +} + +func NSAutoreleasePoolVersion() NSInteger { + ret := (NSInteger)(C.NSAutoreleasePool_Version()) + return ret +} + +func NSAutoreleasePoolAddObject(anObject NSObject) { + C.NSAutoreleasePool_AddObject(anObject.Ptr()) +} + +func NSAutoreleasePoolResolveClassMethod(sel SEL) bool { + ret := (C.NSAutoreleasePool_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSAutoreleasePoolDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSAutoreleasePoolInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSAutoreleasePool_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSAutoreleasePoolCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSAutoreleasePoolClass() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Class())) + return ret +} + +func NSAutoreleasePoolMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSAutoreleasePoolAlloc() *NSAutoreleasePool { + ret := &NSAutoreleasePool{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { + o.Release() + }) + return ret +} + +func (o *NSAutoreleasePool) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSAutoreleasePool) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSAutoreleasePoolClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSAutoreleasePoolKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSAutoreleasePoolInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSAutoreleasePoolResolveInstanceMethod(sel SEL) bool { + ret := (C.NSAutoreleasePool_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSAutoreleasePoolAccessInstanceVariablesDirectly() bool { + ret := (C.NSAutoreleasePool_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSAutoreleasePoolClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_ClassForKeyedUnarchiver())) + return ret +} + +func NSAutoreleasePoolConformsToProtocol(protocol Protocol) bool { + ret := (C.NSAutoreleasePool_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSAutoreleasePoolCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSAutoreleasePoolAllocWithZone(zone *_NSZone) *NSAutoreleasePool { + ret := &NSAutoreleasePool{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { + o.Release() + }) + return ret +} + +func NSAutoreleasePoolHash() NSUInteger { + ret := (NSUInteger)(C.NSAutoreleasePool_Hash()) + return ret +} + +func NSAutoreleasePoolSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Superclass())) + return ret +} + +func NSAutoreleasePoolLoad() { + C.NSAutoreleasePool_Load() +} + +func NSAutoreleasePoolAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSAutoreleasePool_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSAutoreleasePoolIsSubclassOfClass(aClass Class) bool { + ret := (C.NSAutoreleasePool_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSAutoreleasePoolNew() *NSAutoreleasePool { + ret := &NSAutoreleasePool{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { + o.Release() + }) + return ret +} + +func (o *NSAutoreleasePool) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) Dealloc() { + C.NSAutoreleasePool_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ScriptingContains(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSAutoreleasePool_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSAutoreleasePool_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) DoesNotRecognizeSelector(aSelector SEL) { + C.NSAutoreleasePool_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) IsEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) SetNilValueForKey(key *NSString) { + C.NSAutoreleasePool_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSAutoreleasePool_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSAutoreleasePool_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSAutoreleasePool_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSAutoreleasePool_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSAutoreleasePool_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) SetValueForKey(value NSObject, key *NSString) { + C.NSAutoreleasePool_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSAutoreleasePool_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSAutoreleasePool_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSAutoreleasePool_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSAutoreleasePool_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSAutoreleasePool_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSAutoreleasePool_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) IsLike(object *NSString) bool { + ret := (C.NSAutoreleasePool_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSAutoreleasePool_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSAutoreleasePool_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSAutoreleasePool_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSAutoreleasePool_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) IsLessThan(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSAutoreleasePool_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) WillChangeValueForKey(key *NSString) { + C.NSAutoreleasePool_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) DidChangeValueForKey(key *NSString) { + C.NSAutoreleasePool_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) IsGreaterThan(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSAutoreleasePool_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSAutoreleasePool_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) DoesContain(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) Init() *NSAutoreleasePool { + ret := &NSAutoreleasePool{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSAutoreleasePool_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) AddObject(anObject NSObject) { + C.NSAutoreleasePool_inst_AddObject(o.Ptr(), anObject.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) Drain() { + C.NSAutoreleasePool_inst_Drain(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSAutoreleasePool_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) IsNotEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSAutoreleasePool_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSAutoreleasePool_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) ForwardInvocation(anInvocation *NSInvocation) { + C.NSAutoreleasePool_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSAutoreleasePool) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSAutoreleasePool_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSAutoreleasePool) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBPeripheralManagerResolveClassMethod(sel SEL) bool { + ret := (C.CBPeripheralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBPeripheralManagerMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBPeripheralManagerVersion() NSInteger { + ret := (NSInteger)(C.CBPeripheralManager_Version()) + return ret +} + +func CBPeripheralManagerNew() *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + return ret +} + +func CBPeripheralManagerResolveInstanceMethod(sel SEL) bool { + ret := (C.CBPeripheralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBPeripheralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBPeripheralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBPeripheralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBPeripheralManagerClass() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Class())) + return ret +} + +func CBPeripheralManagerLoad() { + C.CBPeripheralManager_Load() +} + +func CBPeripheralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBPeripheralManagerAccessInstanceVariablesDirectly() bool { + ret := (C.CBPeripheralManager_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBPeripheralManagerInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBPeripheralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBPeripheralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBPeripheralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBPeripheralManagerIsSubclassOfClass(aClass Class) bool { + ret := (C.CBPeripheralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func GetCBPeripheralManagerAuthorizationStatus() CBPeripheralManagerAuthorizationStatus { + ret := (CBPeripheralManagerAuthorizationStatus)(C.CBPeripheralManager_AuthorizationStatus()) + return ret +} + +func CBPeripheralManagerCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBPeripheralManagerAllocWithZone(zone *_NSZone) *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + return ret +} + +func CBPeripheralManagerConformsToProtocol(protocol Protocol) bool { + ret := (C.CBPeripheralManager_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBPeripheralManagerHash() NSUInteger { + ret := (NSUInteger)(C.CBPeripheralManager_Hash()) + return ret +} + +func CBPeripheralManagerDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBPeripheralManagerClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_ClassForKeyedUnarchiver())) + return ret +} + +func CBPeripheralManagerSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Superclass())) + return ret +} + +func CBPeripheralManagerDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBPeripheralManagerSetVersion(aVersion NSInteger) { + C.CBPeripheralManager_SetVersion((C.NSInteger)(aVersion)) +} + +func CBPeripheralManagerAlloc() *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + return ret +} + +func (o *CBPeripheralManager) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBPeripheralManager) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBPeripheralManagerClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func (o *CBPeripheralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBPeripheralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ScriptingContains(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBPeripheralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBPeripheralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBPeripheralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBPeripheralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBPeripheralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBPeripheralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBPeripheralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) DidChangeValueForKey(key *NSString) { + C.CBPeripheralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) UpdateValue(value *NSData, characteristic *CBMutableCharacteristic, centrals *NSArray) bool { + ret := (C.CBPeripheralManager_inst_UpdateValue(o.Ptr(), value.Ptr(), characteristic.Ptr(), centrals.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBPeripheralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBPeripheralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBPeripheralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) SetDelegate(delegate NSObject) { + C.CBPeripheralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) SetNilValueForKey(key *NSString) { + C.CBPeripheralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) AddService(service *CBMutableService) { + C.CBPeripheralManager_inst_AddService(o.Ptr(), service.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBPeripheralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBPeripheralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBPeripheralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) WillChangeValueForKey(key *NSString) { + C.CBPeripheralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBPeripheralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) StartAdvertising(advertisementData *NSDictionary) { + C.CBPeripheralManager_inst_StartAdvertising(o.Ptr(), advertisementData.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsNotEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ForwardInvocation(anInvocation *NSInvocation) { + C.CBPeripheralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) DoesContain(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBPeripheralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBPeripheralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsAdvertising() bool { + ret := (C.CBPeripheralManager_inst_IsAdvertising(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) RemoveService(service *CBMutableService) { + C.CBPeripheralManager_inst_RemoveService(o.Ptr(), service.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBPeripheralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) Delegate() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Delegate(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) RemoveAllServices() { + C.CBPeripheralManager_inst_RemoveAllServices(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) SetDesiredConnectionLatency(latency CBPeripheralManagerConnectionLatency, central *CBCentral) { + C.CBPeripheralManager_inst_SetDesiredConnectionLatency(o.Ptr(), (C.CBPeripheralManagerConnectionLatency)(latency), central.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) Dealloc() { + C.CBPeripheralManager_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) RespondToRequest(request *CBATTRequest, result CBATTError) { + C.CBPeripheralManager_inst_RespondToRequest(o.Ptr(), request.Ptr(), (C.CBATTError)(result)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) IsGreaterThan(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBPeripheralManager_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsLike(object *NSString) bool { + ret := (C.CBPeripheralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) DoesNotRecognizeSelector(aSelector SEL) { + C.CBPeripheralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) State() CBManagerState { + ret := (CBManagerState)(C.CBPeripheralManager_inst_State(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBPeripheralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsLessThan(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) StopAdvertising() { + C.CBPeripheralManager_inst_StopAdvertising(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) Init() *CBPeripheralManager { + ret := &CBPeripheralManager{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBPeripheralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) SetValueForKey(value NSObject, key *NSString) { + C.CBPeripheralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBPeripheralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBPeripheralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IsEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheralManager_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBPeripheralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBPeripheralManager) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBPeripheralManager) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBPeripheralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func NSArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSArrayIsSubclassOfClass(aClass Class) bool { + ret := (C.NSArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSArrayWithArray(array *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithArray(array.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArraySuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_Superclass())) + return ret +} + +func NSArrayResolveClassMethod(sel SEL) bool { + ret := (C.NSArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSArrayDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSArrayLoad() { + C.NSArray_Load() +} + +func NSArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSArray_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSArrayClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_ClassForKeyedUnarchiver())) + return ret +} + +func NSArrayAlloc() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func (o *NSArray) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSArraySetVersion(aVersion NSInteger) { + C.NSArray_SetVersion((C.NSInteger)(aVersion)) +} + +func NSArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray { + + goSlice0 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice0[i] = (*objects)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice0[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice0[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSArray { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayWithContentsOfFile(path *NSString) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfFile(path.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayNew() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSArrayWithObject(anObject NSObject) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObject(anObject.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayResolveInstanceMethod(sel SEL) bool { + ret := (C.NSArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSArrayHash() NSUInteger { + ret := (NSUInteger)(C.NSArray_Hash()) + return ret +} + +func NSArrayAllocWithZone(zone *_NSZone) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayConformsToProtocol(protocol Protocol) bool { + ret := (C.NSArray_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSArrayMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSArrayVersion() NSInteger { + ret := (NSInteger)(C.NSArray_Version()) + return ret +} + +func NSArraySupportsSecureCoding() bool { + ret := (C.NSArray_SupportsSecureCoding()) != 0 + return ret +} + +func NSArrayClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSArrayArray() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_Array()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayWithContentsOfURL(url *NSURL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURL(url.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { + + goSlice1 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice1[i] = (*error)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice1[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSArrayInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSArrayClass() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_Class())) + return ret +} + +func NSArrayDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSArrayAccessInstanceVariablesDirectly() bool { + ret := (C.NSArray_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func (o *NSArray) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ForwardInvocation(anInvocation *NSInvocation) { + C.NSArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) FirstObject() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObject(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MakeObjectsPerformSelector(aSelector SEL) { + C.NSArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject) { + C.NSArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingContains(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) WillChangeValueForKey(key *NSString) { + C.NSArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ObjectEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ReverseObjectEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ReverseObjectEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) Dealloc() { + C.NSArray_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsNotEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsEqualToArray(otherArray *NSArray) bool { + ret := (C.NSArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SubarrayWithRange(range_ NSRange) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsLike(object *NSString) bool { + ret := (C.NSArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger { + ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger { + ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SortedArrayHint() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayHint(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DoesContain(object NSObject) bool { + ret := (C.NSArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSArray_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsGreaterThan(object NSObject) bool { + ret := (C.NSArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) WriteToURLError(url *NSURL, error *[]*NSError) bool { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := (C.NSArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { + ret := (C.NSArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DescriptionWithLocale(locale NSObject) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithCoder(aDecoder *NSCoder) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { + ret := (C.NSArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SetNilValueForKey(key *NSString) { + C.NSArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSArray { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithContentsOfFile(path *NSString) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) LastObject() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_LastObject(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ArrayByAddingObject(anObject NSObject) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSArray) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DoesNotRecognizeSelector(aSelector SEL) { + C.NSArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSArray) ObjectAtIndex(index NSUInteger) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) IsEqualTo(object NSObject) bool { + ret := (C.NSArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IndexOfObject(anObject NSObject) NSUInteger { + ret := (NSUInteger)(C.NSArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger { + ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SetValueForKey(value NSObject, key *NSString) { + C.NSArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSArray_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MutableCopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) Count() NSUInteger { + ret := (NSUInteger)(C.NSArray_inst_Count(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithContentsOfURL(url *NSURL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ComponentsJoinedByString(separator *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) IsLessThan(object NSObject) bool { + ret := (C.NSArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ContainsObject(anObject NSObject) bool { + ret := (C.NSArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithArray(array *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArray(o.Ptr(), array.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { + C.NSArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { + C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer) { + C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) GetObjectsRange(objects *[]*Id, range_ NSRange) { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + C.NSArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_)) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + runtime.KeepAlive(o) +} + +func (o *NSArray) Init() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) DidChangeValueForKey(key *NSString) { + C.NSArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSArray) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) SortedArrayUsingSelector(comparator SEL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func NSMutableArrayWithContentsOfURL(url *NSURL) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURL(url.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { + + goSlice1 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice1[i] = (*error)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice1[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + return ret +} + +func NSMutableArraySuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_Superclass())) + return ret +} + +func NSMutableArrayDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSMutableArrayLoad() { + C.NSMutableArray_Load() +} + +func NSMutableArrayCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSMutableArrayWithContentsOfFile(path *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfFile(path.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayAlloc() *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func (o *NSMutableArray) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSMutableArraySetVersion(aVersion NSInteger) { + C.NSMutableArray_SetVersion((C.NSInteger)(aVersion)) +} + +func NSMutableArrayWithObject(anObject NSObject) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObject(anObject.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSMutableArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSMutableArrayNew() *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayHash() NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_Hash()) + return ret +} + +func NSMutableArrayAllocWithZone(zone *_NSZone) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayWithArray(array *NSArray) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithArray(array.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray { + + goSlice0 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice0[i] = (*objects)[i].Ptr() + } + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice0[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice0[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjects(firstObj.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayConformsToProtocol(protocol Protocol) bool { + ret := (C.NSMutableArray_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSMutableArrayArray() *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_Array()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSMutableArray_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSMutableArrayAccessInstanceVariablesDirectly() bool { + ret := (C.NSMutableArray_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSMutableArraySupportsSecureCoding() bool { + ret := (C.NSMutableArray_SupportsSecureCoding()) != 0 + return ret +} + +func NSMutableArrayWithCapacity(numItems NSUInteger) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithCapacity((C.NSUInteger)(numItems))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + return ret +} + +func NSMutableArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSMutableArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSMutableArrayIsSubclassOfClass(aClass Class) bool { + ret := (C.NSMutableArray_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSMutableArrayClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_ClassForKeyedUnarchiver())) + return ret +} + +func NSMutableArrayResolveInstanceMethod(sel SEL) bool { + ret := (C.NSMutableArray_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSMutableArrayMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSMutableArrayVersion() NSInteger { + ret := (NSInteger)(C.NSMutableArray_Version()) + return ret +} + +func NSMutableArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSMutableArray_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSMutableArrayDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSMutableArrayResolveClassMethod(sel SEL) bool { + ret := (C.NSMutableArray_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSMutableArrayClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSMutableArrayClass() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_Class())) + return ret +} + +func (o *NSMutableArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSMutableArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSMutableArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSMutableArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SetNilValueForKey(key *NSString) { + C.NSMutableArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SetValueForKey(value NSObject, key *NSString) { + C.NSMutableArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSMutableArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSMutableArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSMutableArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSMutableArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) MutableCopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSMutableArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSMutableArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSMutableArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSMutableArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SetObjectAtIndexedSubscript(obj NSObject, idx NSUInteger) { + C.NSMutableArray_inst_SetObjectAtIndexedSubscript(o.Ptr(), obj.Ptr(), (C.NSUInteger)(idx)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSMutableArray_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSMutableArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) IsLike(object *NSString) bool { + ret := (C.NSMutableArray_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { + ret := (C.NSMutableArray_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DescriptionWithLocale(locale NSObject) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DidChangeValueForKey(key *NSString) { + C.NSMutableArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SortUsingDescriptors(sortDescriptors *NSArray) { + C.NSMutableArray_inst_SortUsingDescriptors(o.Ptr(), sortDescriptors.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) Dealloc() { + C.NSMutableArray_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSMutableArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) IsEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveObject(anObject NSObject) { + C.NSMutableArray_inst_RemoveObject(o.Ptr(), anObject.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObjectInRange(anObject NSObject, range_ NSRange) { + C.NSMutableArray_inst_RemoveObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSMutableArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSMutableArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InitWithContentsOfFile(path *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveLastObject() { + C.NSMutableArray_inst_RemoveLastObject(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) WriteToURLError(url *NSURL, error *[]*NSError) bool { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := (C.NSMutableArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { + ret := (C.NSMutableArray_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSMutableArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObjectIdenticalTo(anObject NSObject) { + C.NSMutableArray_inst_RemoveObjectIdenticalTo(o.Ptr(), anObject.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObjectIdenticalToInRange(anObject NSObject, range_ NSRange) { + C.NSMutableArray_inst_RemoveObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) Count() NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_inst_Count(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) FirstObject() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObject(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SubarrayWithRange(range_ NSRange) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InsertObjectsAtIndexes(objects *NSArray, indexes *NSIndexSet) { + C.NSMutableArray_inst_InsertObjectsAtIndexes(o.Ptr(), objects.Ptr(), indexes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DoesContain(object NSObject) bool { + ret := (C.NSMutableArray_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSMutableArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSMutableArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSMutableArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ExchangeObjectAtIndexWithObjectAtIndex(idx1 NSUInteger, idx2 NSUInteger) { + C.NSMutableArray_inst_ExchangeObjectAtIndexWithObjectAtIndex(o.Ptr(), (C.NSUInteger)(idx1), (C.NSUInteger)(idx2)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SetArray(otherArray *NSArray) { + C.NSMutableArray_inst_SetArray(o.Ptr(), otherArray.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArray(range_ NSRange, otherArray *NSArray) { + C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArray(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArrayRange(range_ NSRange, otherArray *NSArray, otherRange NSRange) { + C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArrayRange(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr(), (C.NSRange)(otherRange)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObjectsAtIndexes(indexes *NSIndexSet) { + C.NSMutableArray_inst_RemoveObjectsAtIndexes(o.Ptr(), indexes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InitWithCapacity(numItems NSUInteger) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCapacity(o.Ptr(), (C.NSUInteger)(numItems))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsNotEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SortUsingSelector(comparator SEL) { + C.NSMutableArray_inst_SortUsingSelector(o.Ptr(), unsafe.Pointer(comparator)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) Init() *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InitWithCoder(aDecoder *NSCoder) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveObjectAtIndex(index NSUInteger) { + C.NSMutableArray_inst_RemoveObjectAtIndex(o.Ptr(), (C.NSUInteger)(index)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InitWithArray(array *NSArray) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArray(o.Ptr(), array.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SortedArrayHint() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayHint(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) LastObject() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_LastObject(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSMutableArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSMutableArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSMutableArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSMutableArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSMutableArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSMutableArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) GetObjectsRange(objects *[]*Id, range_ NSRange) { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + C.NSMutableArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_)) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) FilterUsingPredicate(predicate *NSPredicate) { + C.NSMutableArray_inst_FilterUsingPredicate(o.Ptr(), predicate.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ScriptingContains(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) WillChangeValueForKey(key *NSString) { + C.NSMutableArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSMutableArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InsertObjectAtIndex(anObject NSObject, index NSUInteger) { + C.NSMutableArray_inst_InsertObjectAtIndex(o.Ptr(), anObject.Ptr(), (C.NSUInteger)(index)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObjectsInArray(otherArray *NSArray) { + C.NSMutableArray_inst_RemoveObjectsInArray(o.Ptr(), otherArray.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveAllObjects() { + C.NSMutableArray_inst_RemoveAllObjects(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ArrayByAddingObject(anObject NSObject) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSMutableArray_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObjectEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsEqualToArray(otherArray *NSArray) bool { + ret := (C.NSMutableArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsGreaterThan(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSMutableArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) DoesNotRecognizeSelector(aSelector SEL) { + C.NSMutableArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MakeObjectsPerformSelector(aSelector SEL) { + C.NSMutableArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject) { + C.NSMutableArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveObjectsInRange(range_ NSRange) { + C.NSMutableArray_inst_RemoveObjectsInRange(o.Ptr(), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ForwardInvocation(anInvocation *NSInvocation) { + C.NSMutableArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSMutableArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSMutableArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { + C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString) { + C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer) { + C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) InitWithContentsOfURL(url *NSURL) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ReplaceObjectsAtIndexesWithObjects(indexes *NSIndexSet, objects *NSArray) { + C.NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(o.Ptr(), indexes.Ptr(), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSMutableArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ContainsObject(anObject NSObject) bool { + ret := (C.NSMutableArray_inst_ContainsObject(o.Ptr(), anObject.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AddObject(anObject NSObject) { + C.NSMutableArray_inst_AddObject(o.Ptr(), anObject.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ReplaceObjectAtIndexWithObject(index NSUInteger, anObject NSObject) { + C.NSMutableArray_inst_ReplaceObjectAtIndexWithObject(o.Ptr(), (C.NSUInteger)(index), anObject.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ObjectAtIndex(index NSUInteger) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AddObjectsFromArray(otherArray *NSArray) { + C.NSMutableArray_inst_AddObjectsFromArray(o.Ptr(), otherArray.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) ReverseObjectEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReverseObjectEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSMutableArray) SortedArrayUsingSelector(comparator SEL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) InitWithObjects(firstObj NSObject, objects ...NSObject) *NSMutableArray { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IndexOfObject(anObject NSObject) NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger { + ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ComponentsJoinedByString(separator *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) IsLessThan(object NSObject) bool { + ret := (C.NSMutableArray_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSMutableArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func NSEnumeratorMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSEnumeratorAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSEnumerator_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSEnumeratorSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_Superclass())) + return ret +} + +func NSEnumeratorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSEnumeratorDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSEnumeratorClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_ClassForKeyedUnarchiver())) + return ret +} + +func NSEnumeratorHash() NSUInteger { + ret := (NSUInteger)(C.NSEnumerator_Hash()) + return ret +} + +func NSEnumeratorClass() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_Class())) + return ret +} + +func NSEnumeratorLoad() { + C.NSEnumerator_Load() +} + +func NSEnumeratorSetVersion(aVersion NSInteger) { + C.NSEnumerator_SetVersion((C.NSInteger)(aVersion)) +} + +func NSEnumeratorNew() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + return ret +} + +func NSEnumeratorAllocWithZone(zone *_NSZone) *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + return ret +} + +func NSEnumeratorAccessInstanceVariablesDirectly() bool { + ret := (C.NSEnumerator_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSEnumeratorDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSEnumeratorCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSEnumerator_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSEnumeratorAlloc() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + return ret +} + +func (o *NSEnumerator) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSEnumeratorResolveClassMethod(sel SEL) bool { + ret := (C.NSEnumerator_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSEnumeratorConformsToProtocol(protocol Protocol) bool { + ret := (C.NSEnumerator_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSEnumeratorCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSEnumeratorClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSEnumeratorVersion() NSInteger { + ret := (NSInteger)(C.NSEnumerator_Version()) + return ret +} + +func NSEnumeratorIsSubclassOfClass(aClass Class) bool { + ret := (C.NSEnumerator_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSEnumeratorResolveInstanceMethod(sel SEL) bool { + ret := (C.NSEnumerator_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSEnumeratorInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSEnumerator_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSEnumeratorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func (o *NSEnumerator) IsLessThan(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IsNotEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) Dealloc() { + C.NSEnumerator_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) IsEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) DidChangeValueForKey(key *NSString) { + C.NSEnumerator_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) SetNilValueForKey(key *NSString) { + C.NSEnumerator_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSEnumerator_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSEnumerator_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSEnumerator_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSEnumerator_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSEnumerator_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) DoesNotRecognizeSelector(aSelector SEL) { + C.NSEnumerator_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSEnumerator_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSEnumerator_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) DoesContain(object NSObject) bool { + ret := (C.NSEnumerator_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSEnumerator_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSEnumerator_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSEnumerator_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSEnumerator_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSEnumerator_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSEnumerator_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSEnumerator_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) AllObjects() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AllObjects(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IsLike(object *NSString) bool { + ret := (C.NSEnumerator_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) SetValueForKey(value NSObject, key *NSString) { + C.NSEnumerator_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSEnumerator_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSEnumerator_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IsGreaterThan(object NSObject) bool { + ret := (C.NSEnumerator_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) Init() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSEnumerator_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSEnumerator_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSEnumerator_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSEnumerator_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSEnumerator_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSEnumerator_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSEnumerator_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSEnumerator_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) WillChangeValueForKey(key *NSString) { + C.NSEnumerator_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSEnumerator_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSEnumerator_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) NextObject() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NextObject(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ForwardInvocation(anInvocation *NSInvocation) { + C.NSEnumerator_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingContains(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSEnumerator_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSEnumerator_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSEnumerator_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSEnumerator_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSEnumerator) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSEnumerator_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSEnumerator) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func NSUUIDNew() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + return ret +} + +func NSUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSUUIDAccessInstanceVariablesDirectly() bool { + ret := (C.NSUUID_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSUUIDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSUUID_Description()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSUUID_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSUUIDConformsToProtocol(protocol Protocol) bool { + ret := (C.NSUUID_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSUUIDHash() NSUInteger { + ret := (NSUInteger)(C.NSUUID_Hash()) + return ret +} + +func NSUUIDCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSUUIDClass() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_Class())) + return ret +} + +func NSUUIDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSUUID_DebugDescription()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSUUIDVersion() NSInteger { + ret := (NSInteger)(C.NSUUID_Version()) + return ret +} + +func NSUUIDAllocWithZone(zone *_NSZone) *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + return ret +} + +func NSUUIDResolveClassMethod(sel SEL) bool { + ret := (C.NSUUID_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSUUIDMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSUUIDSetVersion(aVersion NSInteger) { + C.NSUUID_SetVersion((C.NSInteger)(aVersion)) +} + +func NSUUIDSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_Superclass())) + return ret +} + +func NSUUIDClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_ClassForKeyedUnarchiver())) + return ret +} + +func NSUUIDLoad() { + C.NSUUID_Load() +} + +func NSUUIDClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSUUIDUUID() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_UUID()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + return ret +} + +func NSUUIDResolveInstanceMethod(sel SEL) bool { + ret := (C.NSUUID_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSUUIDAlloc() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + return ret +} + +func (o *NSUUID) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSUUID) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSUUIDSupportsSecureCoding() bool { + ret := (C.NSUUID_SupportsSecureCoding()) != 0 + return ret +} + +func NSUUIDInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSUUIDIsSubclassOfClass(aClass Class) bool { + ret := (C.NSUUID_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func (o *NSUUID) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) Dealloc() { + C.NSUUID_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IsGreaterThan(object NSObject) bool { + ret := (C.NSUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ForwardInvocation(anInvocation *NSInvocation) { + C.NSUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) InitWithUUIDString(string *NSString) *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDString(o.Ptr(), string.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSUUID_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) Init() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) DidChangeValueForKey(key *NSString) { + C.NSUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) InitWithUUIDBytes(bytes *UnsignedChar) *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDBytes(o.Ptr(), unsafe.Pointer(bytes))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IsLike(object *NSString) bool { + ret := (C.NSUUID_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) SetNilValueForKey(key *NSString) { + C.NSUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSUUID_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IsLessThan(object NSObject) bool { + ret := (C.NSUUID_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) DoesContain(object NSObject) bool { + ret := (C.NSUUID_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingContains(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) DoesNotRecognizeSelector(aSelector SEL) { + C.NSUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) WillChangeValueForKey(key *NSString) { + C.NSUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) GetUUIDBytes(uuid *UnsignedChar) { + C.NSUUID_inst_GetUUIDBytes(o.Ptr(), unsafe.Pointer(uuid)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) IsNotEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) IsEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSUUID) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSUUID) SetValueForKey(value NSObject, key *NSString) { + C.NSUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSUUID) UUIDString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSUUID_inst_UUIDString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBAttributeMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBAttributeSetVersion(aVersion NSInteger) { + C.CBAttribute_SetVersion((C.NSInteger)(aVersion)) +} + +func CBAttributeAllocWithZone(zone *_NSZone) *CBAttribute { + ret := &CBAttribute{} + ret.ptr = unsafe.Pointer(C.CBAttribute_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBAttribute) { + o.Release() + }) + return ret +} + +func CBAttributeClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_ClassForKeyedUnarchiver())) + return ret +} + +func CBAttributeCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBAttributeLoad() { + C.CBAttribute_Load() +} + +func CBAttributeConformsToProtocol(protocol Protocol) bool { + ret := (C.CBAttribute_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBAttributeDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBAttribute_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBAttributeNew() *CBAttribute { + ret := &CBAttribute{} + ret.ptr = unsafe.Pointer(C.CBAttribute_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBAttribute) { + o.Release() + }) + return ret +} + +func CBAttributeResolveInstanceMethod(sel SEL) bool { + ret := (C.CBAttribute_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBAttributeDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBAttribute_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBAttributeInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBAttribute_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBAttributeVersion() NSInteger { + ret := (NSInteger)(C.CBAttribute_Version()) + return ret +} + +func CBAttributeIsSubclassOfClass(aClass Class) bool { + ret := (C.CBAttribute_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBAttributeAccessInstanceVariablesDirectly() bool { + ret := (C.CBAttribute_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBAttributeInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBAttribute_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBAttributeClass() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_Class())) + return ret +} + +func CBAttributeCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBAttribute_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBAttributeCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBAttributeCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBAttributeAlloc() *CBAttribute { + ret := &CBAttribute{} + ret.ptr = unsafe.Pointer(C.CBAttribute_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBAttribute) { + o.Release() + }) + return ret +} + +func (o *CBAttribute) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBAttribute) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBAttributeClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBAttributeAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBAttribute_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBAttributeSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_Superclass())) + return ret +} + +func CBAttributeKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBAttribute_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBAttributeResolveClassMethod(sel SEL) bool { + ret := (C.CBAttribute_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBAttributeHash() NSUInteger { + ret := (NSUInteger)(C.CBAttribute_Hash()) + return ret +} + +func (o *CBAttribute) UUID() *CBUUID { + ret := &CBUUID{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_UUID(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ForwardInvocation(anInvocation *NSInvocation) { + C.CBAttribute_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBAttribute_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBAttribute_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBAttribute_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBAttribute_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBAttribute_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBAttribute_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) WillChangeValueForKey(key *NSString) { + C.CBAttribute_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBAttribute_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBAttribute_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBAttribute_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) SetValueForKey(value NSObject, key *NSString) { + C.CBAttribute_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBAttribute_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBAttribute_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) DoesContain(object NSObject) bool { + ret := (C.CBAttribute_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingContains(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBAttribute_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) DidChangeValueForKey(key *NSString) { + C.CBAttribute_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBAttribute_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBAttribute_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) Dealloc() { + C.CBAttribute_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBAttribute_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBAttribute_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBAttribute_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsLike(object *NSString) bool { + ret := (C.CBAttribute_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsNotEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBAttribute_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBAttribute_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBAttribute_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsGreaterThan(object NSObject) bool { + ret := (C.CBAttribute_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBAttribute_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBAttribute_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBAttribute_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBAttribute_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBAttribute_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBAttribute_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBAttribute_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) SetNilValueForKey(key *NSString) { + C.CBAttribute_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBAttribute_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBAttribute_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBAttribute_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) DoesNotRecognizeSelector(aSelector SEL) { + C.CBAttribute_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) IsLessThan(object NSObject) bool { + ret := (C.CBAttribute_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBAttribute_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBAttribute_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBAttribute_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) IsEqualTo(object NSObject) bool { + ret := (C.CBAttribute_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBAttribute_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBAttribute_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBAttribute) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBAttribute) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBAttribute_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func NSDictionaryConformsToProtocol(protocol Protocol) bool { + ret := (C.NSDictionary_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSDictionaryNew() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSDictionaryDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionarySetVersion(aVersion NSInteger) { + C.NSDictionary_SetVersion((C.NSInteger)(aVersion)) +} + +func NSDictionaryWithContentsOfFile(path *NSString) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfFile(path.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryWithContentsOfURL(url *NSURL) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURL(url.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary { + + goSlice1 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice1[i] = (*error)[i].Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice1[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryResolveClassMethod(sel SEL) bool { + ret := (C.NSDictionary_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSDictionaryDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionaryInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSDictionary_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionaryHash() NSUInteger { + ret := (NSUInteger)(C.NSDictionary_Hash()) + return ret +} + +func NSDictionaryAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSDictionary_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSDictionaryWithObjectForKey(object NSObject, key NSObject) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectForKey(object.Ptr(), key.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeys(objects.Ptr(), keys.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary { + + goSlice0 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice0[i] = (*objects)[i].Ptr() + } + + goSlice1 := make([]unsafe.Pointer,cap(*keys)) + for i := 0; i < len(*keys); i++ { + goSlice1[i] = (*keys)[i].Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeysCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice0[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice0[i] + } + (*keys) = (*keys)[:cap(*keys)] + for i := 0; i < len(*keys); i++ { + if goSlice1[i] == nil { + (*keys) = (*keys)[:i] + break + } + if (*keys)[i] == nil { + (*keys)[i] = &Id{} + runtime.SetFinalizer((*keys)[i], func(o *Id) { + o.Release() + }) + } + (*keys)[i].ptr = goSlice1[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSDictionary_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionaryClass() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_Class())) + return ret +} + +func NSDictionaryLoad() { + C.NSDictionary_Load() +} + +func NSDictionaryAllocWithZone(zone *_NSZone) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSDictionarySharedKeySetForKeys(keys *NSArray) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_SharedKeySetForKeys(keys.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionarySuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_Superclass())) + return ret +} + +func NSDictionaryClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_ClassForKeyedUnarchiver())) + return ret +} + +func NSDictionaryClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDictionaryWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsAndKeys(firstObject.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryDictionary() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_Dictionary()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryResolveInstanceMethod(sel SEL) bool { + ret := (C.NSDictionary_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSDictionaryAlloc() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func (o *NSDictionary) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSDictionaryIsSubclassOfClass(aClass Class) bool { + ret := (C.NSDictionary_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSDictionarySupportsSecureCoding() bool { + ret := (C.NSDictionary_SupportsSecureCoding()) != 0 + return ret +} + +func NSDictionaryWithDictionary(dict *NSDictionary) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithDictionary(dict.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + return ret +} + +func NSDictionaryAccessInstanceVariablesDirectly() bool { + ret := (C.NSDictionary_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSDictionaryInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSDictionary_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSDictionaryCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSDictionary_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSDictionaryCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSDictionaryCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSDictionaryVersion() NSInteger { + ret := (NSInteger)(C.NSDictionary_Version()) + return ret +} + +func (o *NSDictionary) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSDictionary_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileSystemFileNumber() NSUInteger { + ret := (NSUInteger)(C.NSDictionary_inst_FileSystemFileNumber(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ObjectForKey(aKey NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKey(o.Ptr(), aKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileHFSTypeCode() OSType { + ret := (OSType)(C.NSDictionary_inst_FileHFSTypeCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileIsImmutable() bool { + ret := (C.NSDictionary_inst_FileIsImmutable(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSDictionary_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSDictionary_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSDictionary_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSDictionary_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSDictionary_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) MutableCopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithCoder(aDecoder *NSCoder) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSDictionary_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) FileOwnerAccountID() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountID(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSDictionary_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSDictionary_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSDictionary_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) FileGroupOwnerAccountName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsNotEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSDictionary_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSDictionary_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) KeyEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeyEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileSize() UnsignedLongLong { + ret := (UnsignedLongLong)(C.NSDictionary_inst_FileSize(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSDictionary_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) Init() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSDictionary_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) IsEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) GetObjectsAndKeys(objects *[]*Id, keys *[]*Id, count NSUInteger) { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + + goSlice2 := make([]unsafe.Pointer,cap(*keys)) + for i := 0; i < len(*keys); i++ { + goSlice2[i] = (*keys)[i].Ptr() + } + C.NSDictionary_inst_GetObjectsAndKeys(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count)) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + (*keys) = (*keys)[:cap(*keys)] + for i := 0; i < len(*keys); i++ { + if goSlice2[i] == nil { + (*keys) = (*keys)[:i] + break + } + if (*keys)[i] == nil { + (*keys)[i] = &Id{} + runtime.SetFinalizer((*keys)[i], func(o *Id) { + o.Release() + }) + } + (*keys)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) +} + +func (o *NSDictionary) GetObjectsAndKeysCount(objects *[]*Id, keys *[]*Id, count NSUInteger) { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + + goSlice2 := make([]unsafe.Pointer,cap(*keys)) + for i := 0; i < len(*keys); i++ { + goSlice2[i] = (*keys)[i].Ptr() + } + C.NSDictionary_inst_GetObjectsAndKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count)) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + (*keys) = (*keys)[:cap(*keys)] + for i := 0; i < len(*keys); i++ { + if goSlice2[i] == nil { + (*keys) = (*keys)[:i] + break + } + if (*keys)[i] == nil { + (*keys)[i] = &Id{} + runtime.SetFinalizer((*keys)[i], func(o *Id) { + o.Release() + }) + } + (*keys)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) +} + +func (o *NSDictionary) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSDictionary_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) SetValueForKey(value NSObject, key *NSString) { + C.NSDictionary_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSDictionary_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSDictionary_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingContains(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AllValues() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllValues(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileOwnerAccountName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) KeysSortedByValueUsingSelector(comparator SEL) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeysSortedByValueUsingSelector(o.Ptr(), unsafe.Pointer(comparator))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSDictionary_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSDictionary_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSDictionary_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSDictionary_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) FileType() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileType(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsLessThan(object NSObject) bool { + ret := (C.NSDictionary_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSDictionary_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSDictionary_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ObjectForKeyedSubscript(key NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKeyedSubscript(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSDictionary_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSDictionary_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileExtensionHidden() bool { + ret := (C.NSDictionary_inst_FileExtensionHidden(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSDictionary_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ObjectEnumerator() *NSEnumerator { + ret := &NSEnumerator{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectEnumerator(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSEnumerator) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileModificationDate() *NSDate { + ret := &NSDate{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileModificationDate(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDate) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FilePosixPermissions() NSUInteger { + ret := (NSUInteger)(C.NSDictionary_inst_FilePosixPermissions(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithContentsOfURL(url *NSURL) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AllKeysForObject(anObject NSObject) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeysForObject(o.Ptr(), anObject.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) DidChangeValueForKey(key *NSString) { + C.NSDictionary_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSDictionary_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSDictionary_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) SetNilValueForKey(key *NSString) { + C.NSDictionary_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) FileIsAppendOnly() bool { + ret := (C.NSDictionary_inst_FileIsAppendOnly(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileHFSCreatorCode() OSType { + ret := (OSType)(C.NSDictionary_inst_FileHFSCreatorCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithObjectsAndKeys(firstObject NSObject, objects ...NSObject) *NSDictionary { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsAndKeys(o.Ptr(), firstObject.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DoesNotRecognizeSelector(aSelector SEL) { + C.NSDictionary_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeys(o.Ptr(), objects.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary { + + goSlice1 := make([]unsafe.Pointer,cap(*objects)) + for i := 0; i < len(*objects); i++ { + goSlice1[i] = (*objects)[i].Ptr() + } + + goSlice2 := make([]unsafe.Pointer,cap(*keys)) + for i := 0; i < len(*keys); i++ { + goSlice2[i] = (*keys)[i].Ptr() + } + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(cnt))) + (*objects) = (*objects)[:cap(*objects)] + for i := 0; i < len(*objects); i++ { + if goSlice1[i] == nil { + (*objects) = (*objects)[:i] + break + } + if (*objects)[i] == nil { + (*objects)[i] = &Id{} + runtime.SetFinalizer((*objects)[i], func(o *Id) { + o.Release() + }) + } + (*objects)[i].ptr = goSlice1[i] + } + (*keys) = (*keys)[:cap(*keys)] + for i := 0; i < len(*keys); i++ { + if goSlice2[i] == nil { + (*keys) = (*keys)[:i] + break + } + if (*keys)[i] == nil { + (*keys)[i] = &Id{} + runtime.SetFinalizer((*keys)[i], func(o *Id) { + o.Release() + }) + } + (*keys)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsLike(object *NSString) bool { + ret := (C.NSDictionary_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithDictionary(otherDictionary *NSDictionary) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionary(o.Ptr(), otherDictionary.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithDictionaryCopyItems(otherDictionary *NSDictionary, flag BOOL) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionaryCopyItems(o.Ptr(), otherDictionary.Ptr(), (C.BOOL)(flag))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsEqualToDictionary(otherDictionary *NSDictionary) bool { + ret := (C.NSDictionary_inst_IsEqualToDictionary(o.Ptr(), otherDictionary.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DescriptionWithLocale(locale NSObject) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSDictionary_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DoesContain(object NSObject) bool { + ret := (C.NSDictionary_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileSystemNumber() NSInteger { + ret := (NSInteger)(C.NSDictionary_inst_FileSystemNumber(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileGroupOwnerAccountID() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountID(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSDictionary_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger { + + goSlice2 := make([]unsafe.Pointer,cap(*buffer)) + for i := 0; i < len(*buffer); i++ { + goSlice2[i] = (*buffer)[i].Ptr() + } + ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_))) + (*buffer) = (*buffer)[:cap(*buffer)] + for i := 0; i < len(*buffer); i++ { + if goSlice2[i] == nil { + (*buffer) = (*buffer)[:i] + break + } + if (*buffer)[i] == nil { + (*buffer)[i] = &Id{} + runtime.SetFinalizer((*buffer)[i], func(o *Id) { + o.Release() + }) + } + (*buffer)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) WillChangeValueForKey(key *NSString) { + C.NSDictionary_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSDictionary_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSDictionary_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsGreaterThan(object NSObject) bool { + ret := (C.NSDictionary_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSDictionary_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) InitWithContentsOfFile(path *NSString) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DescriptionInStringsFileFormat() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionInStringsFileFormat(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSDictionary_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSDictionary_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSDictionary_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSDictionary_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ForwardInvocation(anInvocation *NSInvocation) { + C.NSDictionary_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) Count() NSUInteger { + ret := (NSUInteger)(C.NSDictionary_inst_Count(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) FileCreationDate() *NSDate { + ret := &NSDate{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileCreationDate(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDate) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { + ret := (C.NSDictionary_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ObjectsForKeysNotFoundMarker(keys *NSArray, marker NSObject) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectsForKeysNotFoundMarker(o.Ptr(), keys.Ptr(), marker.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSDictionary_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) Dealloc() { + C.NSDictionary_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) WriteToURLError(url *NSURL, error *[]*NSError) bool { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := (C.NSDictionary_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { + ret := (C.NSDictionary_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSDictionary) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSDictionary_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSDictionary) AllKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func NSObjectClass() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_Class())) + return ret +} + +func NSObjectMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSObjectClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSObject_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSObjectNew() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSObjectKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSObject_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSObjectInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSObject_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSObjectVersion() NSInteger { + ret := (NSInteger)(C.NSObject_Version()) + return ret +} + +func NSObjectResolveClassMethod(sel SEL) bool { + ret := (C.NSObject_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSObjectAccessInstanceVariablesDirectly() bool { + ret := (C.NSObject_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSObjectLoad() { + C.NSObject_Load() +} + +func NSObjectCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSObjectDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSObjectSetVersion(aVersion NSInteger) { + C.NSObject_SetVersion((C.NSInteger)(aVersion)) +} + +func NSObjectAlloc() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func (o *Id) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSObjectResolveInstanceMethod(sel SEL) bool { + ret := (C.NSObject_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSObjectSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_Superclass())) + return ret +} + +func NSObjectClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_ClassForKeyedUnarchiver())) + return ret +} + +func NSObjectConformsToProtocol(protocol Protocol) bool { + ret := (C.NSObject_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSObjectHash() NSUInteger { + ret := (NSUInteger)(C.NSObject_Hash()) + return ret +} + +func NSObjectCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSObject_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSObjectCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSObject_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSObjectCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSObject_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSObjectAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSObject_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSObjectIsSubclassOfClass(aClass Class) bool { + ret := (C.NSObject_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSObjectAllocWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSObjectDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSObjectInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSObject_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func (o *Id) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSObject_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *Id) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSObject_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *Id) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DidChangeValueForKey(key *NSString) { + C.NSObject_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSObject_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSObject_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) Retain() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSObject_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Autorelease() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsGreaterThan(object NSObject) bool { + ret := (C.NSObject_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DoesContain(object NSObject) bool { + ret := (C.NSObject_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) SetNilValueForKey(key *NSString) { + C.NSObject_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) RespondsToSelector(aSelector SEL) bool { + ret := (C.NSObject_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSObject_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSObject_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSObject_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSObject_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSObject_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Self() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Init() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsNotEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsProxy() bool { + ret := (C.NSObject_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsMemberOfClass(aClass Class) bool { + ret := (C.NSObject_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSObject_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSObject_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSObject_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ScriptingContains(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSObject_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *Id) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSObject_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *Id) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSObject_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSObject_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *Id) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSObject_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSObject_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSObject_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSObject_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSObject_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSObject_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSObject_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsLike(object *NSString) bool { + ret := (C.NSObject_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Dealloc() { + C.NSObject_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSObject_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsLessThan(object NSObject) bool { + ret := (C.NSObject_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.NSObject_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Release() { + C.NSObject_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) IsEqual(object NSObject) bool { + ret := (C.NSObject_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Hash() NSUInteger { + ret := (NSUInteger)(C.NSObject_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSObject_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSObject_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) WillChangeValueForKey(key *NSString) { + C.NSObject_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSObject_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSObject_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) RetainCount() NSUInteger { + ret := (NSUInteger)(C.NSObject_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ForwardInvocation(anInvocation *NSInvocation) { + C.NSObject_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSObject_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSObject_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *Id) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSObject_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSObject_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) SetValueForKey(value NSObject, key *NSString) { + C.NSObject_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSObject_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSObject_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) DoesNotRecognizeSelector(aSelector SEL) { + C.NSObject_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *Id) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.NSObject_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSObject_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSObject_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSObject_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *Id) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSObject_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *Id) IsKindOfClass(aClass Class) bool { + ret := (C.NSObject_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func NSDataClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSData_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDataAllocWithZone(zone *_NSZone) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataData() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_Data()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesLength(unsafe.Pointer(bytes), (C.NSUInteger)(length))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLength(unsafe.Pointer(bytes), (C.NSUInteger)(length))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLengthFreeWhenDone(unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithData(data *NSData) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithData(data.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSData_ClassForKeyedUnarchiver())) + return ret +} + +func NSDataHash() NSUInteger { + ret := (NSUInteger)(C.NSData_Hash()) + return ret +} + +func NSDataIsSubclassOfClass(aClass Class) bool { + ret := (C.NSData_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSDataWithContentsOfFile(path *NSString) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFile(path.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice2[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptions(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice2[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice2[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptionsError(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice2[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataNew() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataVersion() NSInteger { + ret := (NSInteger)(C.NSData_Version()) + return ret +} + +func NSDataResolveClassMethod(sel SEL) bool { + ret := (C.NSData_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSDataCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSData_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSDataCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSData_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSDataCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSData_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSDataCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSDataResolveInstanceMethod(sel SEL) bool { + ret := (C.NSData_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSDataSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSData_Superclass())) + return ret +} + +func NSDataDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDataAccessInstanceVariablesDirectly() bool { + ret := (C.NSData_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSDataAlloc() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func (o *NSData) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSDataSupportsSecureCoding() bool { + ret := (C.NSData_SupportsSecureCoding()) != 0 + return ret +} + +func NSDataWithContentsOfURL(url *NSURL) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURL(url.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice2[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptions(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice2[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice2 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice2[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptionsError(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice2[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + return ret +} + +func NSDataDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSDataSetVersion(aVersion NSInteger) { + C.NSData_SetVersion((C.NSInteger)(aVersion)) +} + +func NSDataClass() Class { + ret := (Class)(unsafe.Pointer(C.NSData_Class())) + return ret +} + +func NSDataMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSDataInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSData_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSDataConformsToProtocol(protocol Protocol) bool { + ret := (C.NSData_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSDataAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSData_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSDataInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSData_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSDataKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSData_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSDataLoad() { + C.NSData_Load() +} + +func (o *NSData) InitWithData(data *NSData) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithData(o.Ptr(), data.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Retain() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSData_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Release() { + C.NSData_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.NSData_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithBase64EncodedStringOptions(base64String *NSString, options NSDataBase64DecodingOptions) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedStringOptions(o.Ptr(), base64String.Ptr(), (C.NSDataBase64DecodingOptions)(options))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool { + ret := (C.NSData_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WriteToFileOptions(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := (C.NSData_inst_WriteToFileOptions(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WriteToFileOptionsError(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := (C.NSData_inst_WriteToFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) SubdataWithRange(range_ NSRange) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_SubdataWithRange(o.Ptr(), (C.NSRange)(range_))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) SetNilValueForKey(key *NSString) { + C.NSData_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) IsLessThan(object NSObject) bool { + ret := (C.NSData_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSData_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) SetValueForKey(value NSObject, key *NSString) { + C.NSData_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSData_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSData_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Autorelease() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSData_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) RetainCount() NSUInteger { + ret := (NSUInteger)(C.NSData_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSData_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSData_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSData) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ForwardInvocation(anInvocation *NSInvocation) { + C.NSData_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithBase64EncodedDataOptions(base64Data *NSData, options NSDataBase64DecodingOptions) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedDataOptions(o.Ptr(), base64Data.Ptr(), (C.NSDataBase64DecodingOptions)(options))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsEqualToData(other *NSData) bool { + ret := (C.NSData_inst_IsEqualToData(o.Ptr(), other.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) DidChangeValueForKey(key *NSString) { + C.NSData_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSData_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSData_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSData_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSData) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSData_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) GetBytesLength(buffer unsafe.Pointer, length NSUInteger) { + C.NSData_inst_GetBytesLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(length)) + runtime.KeepAlive(o) +} + +func (o *NSData) GetBytesRange(buffer unsafe.Pointer, range_ NSRange) { + C.NSData_inst_GetBytesRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSData) RespondsToSelector(aSelector SEL) bool { + ret := (C.NSData_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.NSData_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSData_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSData_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSData_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSData_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ScriptingContains(object NSObject) bool { + ret := (C.NSData_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSData_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.NSData_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSData_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSData_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfURL(url *NSURL) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptions(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsEqual(object NSObject) bool { + ret := (C.NSData_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSData_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) WriteToURLAtomically(url *NSURL, atomically BOOL) bool { + ret := (C.NSData_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WriteToURLOptions(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := (C.NSData_inst_WriteToURLOptions(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WriteToURLOptionsError(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := (C.NSData_inst_WriteToURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WillChangeValueForKey(key *NSString) { + C.NSData_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSData_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSData_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSData_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Length() NSUInteger { + ret := (NSUInteger)(C.NSData_inst_Length(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Init() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Base64EncodedStringWithOptions(options NSDataBase64EncodingOptions) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedStringWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Bytes() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_Bytes(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.NSData_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsLike(object *NSString) bool { + ret := (C.NSData_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) RangeOfDataOptions(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange { + ret := (NSRange)(C.NSData_inst_RangeOfDataOptions(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) RangeOfDataOptionsRange(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange { + ret := (NSRange)(C.NSData_inst_RangeOfDataOptionsRange(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSData_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSData_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSData_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSData_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsGreaterThan(object NSObject) bool { + ret := (C.NSData_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) DoesContain(object NSObject) bool { + ret := (C.NSData_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Dealloc() { + C.NSData_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsKindOfClass(aClass Class) bool { + ret := (C.NSData_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSData_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSData_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSData_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSData_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) Self() *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSData_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSData_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSData_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSData_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSData_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSData_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSData_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSData_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSData_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSData_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) DoesNotRecognizeSelector(aSelector SEL) { + C.NSData_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSData) Base64EncodedDataWithOptions(options NSDataBase64EncodingOptions) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedDataWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSData_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSData) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSData_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSData) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSData_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSData_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsEqualTo(object NSObject) bool { + ret := (C.NSData_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSData_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSData_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSData) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSData_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSData) MutableCopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfFile(path *NSString) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptions(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) InitWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData { + + goSlice3 := make([]unsafe.Pointer,cap(*errorPtr)) + for i := 0; i < len(*errorPtr); i++ { + goSlice3[i] = (*errorPtr)[i].Ptr() + } + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*errorPtr) = (*errorPtr)[:cap(*errorPtr)] + for i := 0; i < len(*errorPtr); i++ { + if goSlice3[i] == nil { + (*errorPtr) = (*errorPtr)[:i] + break + } + if (*errorPtr)[i] == nil { + (*errorPtr)[i] = &NSError{} + runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) { + o.Release() + }) + } + (*errorPtr)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsNotEqualTo(object NSObject) bool { + ret := (C.NSData_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSData_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSData) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSData_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSData) IsProxy() bool { + ret := (C.NSData_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsMemberOfClass(aClass Class) bool { + ret := (C.NSData_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) Hash() NSUInteger { + ret := (NSUInteger)(C.NSData_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSData) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSData_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func CBManagerIsSubclassOfClass(aClass Class) bool { + ret := (C.CBManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBManagerAllocWithZone(zone *_NSZone) *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + return ret +} + +func CBManagerAccessInstanceVariablesDirectly() bool { + ret := (C.CBManager_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBManagerSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_Superclass())) + return ret +} + +func CBManagerHash() NSUInteger { + ret := (NSUInteger)(C.CBManager_Hash()) + return ret +} + +func CBManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBManagerDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBManagerNew() *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + return ret +} + +func CBManagerInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBManagerSetVersion(aVersion NSInteger) { + C.CBManager_SetVersion((C.NSInteger)(aVersion)) +} + +func CBManagerResolveInstanceMethod(sel SEL) bool { + ret := (C.CBManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBManagerClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_ClassForKeyedUnarchiver())) + return ret +} + +func CBManagerAlloc() *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + return ret +} + +func (o *CBManager) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBManager) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBManagerClass() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_Class())) + return ret +} + +func CBManagerClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBManager_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBManagerResolveClassMethod(sel SEL) bool { + ret := (C.CBManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBManagerDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBManagerConformsToProtocol(protocol Protocol) bool { + ret := (C.CBManager_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBManagerMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBManagerVersion() NSInteger { + ret := (NSInteger)(C.CBManager_Version()) + return ret +} + +func CBManagerLoad() { + C.CBManager_Load() +} + +func CBManagerCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func (o *CBManager) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.CBManager_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBManager) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) SetValueForKey(value NSObject, key *NSString) { + C.CBManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) DoesContain(object NSObject) bool { + ret := (C.CBManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) RespondsToSelector(aSelector SEL) bool { + ret := (C.CBManager_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsEqual(object NSObject) bool { + ret := (C.CBManager_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.CBManager_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBManager_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Self() *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBManager_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsNotEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsMemberOfClass(aClass Class) bool { + ret := (C.CBManager_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsLike(object *NSString) bool { + ret := (C.CBManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Retain() *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsGreaterThan(object NSObject) bool { + ret := (C.CBManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ForwardInvocation(anInvocation *NSInvocation) { + C.CBManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) DidChangeValueForKey(key *NSString) { + C.CBManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) SetNilValueForKey(key *NSString) { + C.CBManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBManager) IsLessThan(object NSObject) bool { + ret := (C.CBManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) Hash() NSUInteger { + ret := (NSUInteger)(C.CBManager_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) RetainCount() NSUInteger { + ret := (NSUInteger)(C.CBManager_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) ScriptingContains(object NSObject) bool { + ret := (C.CBManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsKindOfClass(aClass Class) bool { + ret := (C.CBManager_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Dealloc() { + C.CBManager_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Release() { + C.CBManager_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) WillChangeValueForKey(key *NSString) { + C.CBManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBManager) State() CBManagerState { + ret := (CBManagerState)(C.CBManager_inst_State(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBManager) Autorelease() *CBManager { + ret := &CBManager{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) IsProxy() bool { + ret := (C.CBManager_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) DoesNotRecognizeSelector(aSelector SEL) { + C.CBManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBManager) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBManager) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBCentralManagerClass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_Class())) + return ret +} + +func CBCentralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralManagerIsSubclassOfClass(aClass Class) bool { + ret := (C.CBCentralManager_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBCentralManagerAccessInstanceVariablesDirectly() bool { + ret := (C.CBCentralManager_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBCentralManagerHash() NSUInteger { + ret := (NSUInteger)(C.CBCentralManager_Hash()) + return ret +} + +func CBCentralManagerDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralManagerAlloc() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + return ret +} + +func (o *CBCentralManager) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBCentralManagerAllocWithZone(zone *_NSZone) *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + return ret +} + +func CBCentralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralManagerDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralManagerMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBCentralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBCentralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCentralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBCentralManager_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBCentralManagerResolveInstanceMethod(sel SEL) bool { + ret := (C.CBCentralManager_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCentralManagerClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralManagerResolveClassMethod(sel SEL) bool { + ret := (C.CBCentralManager_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCentralManagerConformsToProtocol(protocol Protocol) bool { + ret := (C.CBCentralManager_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBCentralManagerVersion() NSInteger { + ret := (NSInteger)(C.CBCentralManager_Version()) + return ret +} + +func CBCentralManagerLoad() { + C.CBCentralManager_Load() +} + +func CBCentralManagerSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_Superclass())) + return ret +} + +func CBCentralManagerNew() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + return ret +} + +func CBCentralManagerInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBCentralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBCentralManagerSetVersion(aVersion NSInteger) { + C.CBCentralManager_SetVersion((C.NSInteger)(aVersion)) +} + +func CBCentralManagerClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_ClassForKeyedUnarchiver())) + return ret +} + +func CBCentralManagerCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func (o *CBCentralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsKindOfClass(aClass Class) bool { + ret := (C.CBCentralManager_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RespondsToSelector(aSelector SEL) bool { + ret := (C.CBCentralManager_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCentralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.CBCentralManager_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) State() CBManagerState { + ret := (CBManagerState)(C.CBCentralManager_inst_State(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsEqual(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsScanning() bool { + ret := (C.CBCentralManager_inst_IsScanning(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetValueForKey(value NSObject, key *NSString) { + C.CBCentralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBCentralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBCentralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DoesNotRecognizeSelector(aSelector SEL) { + C.CBCentralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.CBCentralManager_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) StopScan() { + C.CBCentralManager_inst_StopScan(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBCentralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Dealloc() { + C.CBCentralManager_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScanForPeripheralsWithServices(serviceUUIDs *NSArray, options *NSDictionary) { + C.CBCentralManager_inst_ScanForPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr(), options.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DidChangeValueForKey(key *NSString) { + C.CBCentralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Init() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ConnectPeripheral(peripheral *CBPeripheral, options *NSDictionary) { + C.CBCentralManager_inst_ConnectPeripheral(o.Ptr(), peripheral.Ptr(), options.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) IsNotEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsLessThan(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsLike(object *NSString) bool { + ret := (C.CBCentralManager_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetNilValueForKey(key *NSString) { + C.CBCentralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBCentralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBCentralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBCentralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RetainCount() NSUInteger { + ret := (NSUInteger)(C.CBCentralManager_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentralManager_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsGreaterThan(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBCentralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCentralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCentralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCentralManager_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsProxy() bool { + ret := (C.CBCentralManager_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Delegate() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Delegate(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBCentralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Release() { + C.CBCentralManager_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RetrievePeripheralsWithIdentifiers(identifiers *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrievePeripheralsWithIdentifiers(o.Ptr(), identifiers.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetDelegate(delegate NSObject) { + C.CBCentralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DoesContain(object NSObject) bool { + ret := (C.CBCentralManager_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RetrieveConnectedPeripheralsWithServices(serviceUUIDs *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrieveConnectedPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Self() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) CancelPeripheralConnection(peripheral *CBPeripheral) { + C.CBCentralManager_inst_CancelPeripheralConnection(o.Ptr(), peripheral.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBCentralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBCentralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBCentralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) WillChangeValueForKey(key *NSString) { + C.CBCentralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) Autorelease() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) IsMemberOfClass(aClass Class) bool { + ret := (C.CBCentralManager_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ForwardInvocation(anInvocation *NSInvocation) { + C.CBCentralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingContains(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBCentralManager_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Hash() NSUInteger { + ret := (NSUInteger)(C.CBCentralManager_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCentralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCentralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBCentralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentralManager) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBCentralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentralManager) Retain() *CBCentralManager { + ret := &CBCentralManager{} + ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentralManager) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func CBCentralAlloc() *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + return ret +} + +func (o *CBCentral) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *CBCentral) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func CBCentralSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_Superclass())) + return ret +} + +func CBCentralCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.CBCentral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func CBCentralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCentral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCentralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.CBCentral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func CBCentralInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.CBCentral_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func CBCentralResolveClassMethod(sel SEL) bool { + ret := (C.CBCentral_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCentralLoad() { + C.CBCentral_Load() +} + +func CBCentralClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_ClassForKeyedUnarchiver())) + return ret +} + +func CBCentralAllocWithZone(zone *_NSZone) *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + return ret +} + +func CBCentralClass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_Class())) + return ret +} + +func CBCentralMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBCentralSetVersion(aVersion NSInteger) { + C.CBCentral_SetVersion((C.NSInteger)(aVersion)) +} + +func CBCentralResolveInstanceMethod(sel SEL) bool { + ret := (C.CBCentral_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func CBCentralConformsToProtocol(protocol Protocol) bool { + ret := (C.CBCentral_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func CBCentralDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralAccessInstanceVariablesDirectly() bool { + ret := (C.CBCentral_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func CBCentralVersion() NSInteger { + ret := (NSInteger)(C.CBCentral_Version()) + return ret +} + +func CBCentralCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func CBCentralDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralHash() NSUInteger { + ret := (NSUInteger)(C.CBCentral_Hash()) + return ret +} + +func CBCentralAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.CBCentral_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func CBCentralNew() *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + return ret +} + +func CBCentralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.CBCentral_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func CBCentralIsSubclassOfClass(aClass Class) bool { + ret := (C.CBCentral_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func CBCentralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCentral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func (o *CBCentral) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsMemberOfClass(aClass Class) bool { + ret := (C.CBCentral_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) WillChangeValueForKey(key *NSString) { + C.CBCentral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) RetainCount() NSUInteger { + ret := (NSUInteger)(C.CBCentral_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Identifier() *NSUUID { + ret := &NSUUID{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Identifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSUUID) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingContains(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentral_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.CBCentral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsLike(object *NSString) bool { + ret := (C.CBCentral_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsProxy() bool { + ret := (C.CBCentral_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Release() { + C.CBCentral_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) SetObservationInfo(observationInfo unsafe.Pointer) { + C.CBCentral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) DoesContain(object NSObject) bool { + ret := (C.CBCentral_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsGreaterThan(object NSObject) bool { + ret := (C.CBCentral_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.CBCentral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.CBCentral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.CBCentral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ScriptingIsLessThan(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsLessThan(object NSObject) bool { + ret := (C.CBCentral_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.CBCentral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ClassCode() FourCharCode { + ret := (FourCharCode)(C.CBCentral_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCentral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.CBCentral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) SetNilValueForKey(key *NSString) { + C.CBCentral_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCentral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.CBCentral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) Autorelease() *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) SetValueForKey(value NSObject, key *NSString) { + C.CBCentral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.CBCentral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.CBCentral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.CBCentral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCentral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.CBCentral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.CBCentral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) Self() *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingEndsWith(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Dealloc() { + C.CBCentral_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ForwardInvocation(anInvocation *NSInvocation) { + C.CBCentral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.CBCentral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.CBCentral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.CBCentral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) DidChangeValueForKey(key *NSString) { + C.CBCentral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.CBCentral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) RespondsToSelector(aSelector SEL) bool { + ret := (C.CBCentral_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.CBCentral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCentral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) Hash() NSUInteger { + ret := (NSUInteger)(C.CBCentral_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsNotEqualTo(object NSObject) bool { + ret := (C.CBCentral_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) IsEqual(object NSObject) bool { + ret := (C.CBCentral_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ScriptingBeginsWith(object NSObject) bool { + ret := (C.CBCentral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.CBCentral_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.CBCentral_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsKindOfClass(aClass Class) bool { + ret := (C.CBCentral_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Retain() *CBCentral { + ret := &CBCentral{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *CBCentral) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.CBCentral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.CBCentral_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) DoesNotRecognizeSelector(aSelector SEL) { + C.CBCentral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *CBCentral) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) MaximumUpdateValueLength() NSUInteger { + ret := (NSUInteger)(C.CBCentral_inst_MaximumUpdateValueLength(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.CBCentral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *CBCentral) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.CBCentral_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func NSStringCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSString_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSStringCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSString_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSStringCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSString_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSStringWritableTypeIdentifiersForItemProvider() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_WritableTypeIdentifiersForItemProvider()) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSStringKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSString_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringLoad() { + C.NSString_Load() +} + +func NSStringSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSString_Superclass())) + return ret +} + +func NSStringDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringLocalizedStringWithFormat(format *NSString, objects ...NSObject) *NSString { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_LocalizedStringWithFormat(format.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringNew() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSString_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSStringHash() NSUInteger { + ret := (NSUInteger)(C.NSString_Hash()) + return ret +} + +func NSStringWithUTF8String(nullTerminatedCString *Char) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithUTF8String(unsafe.Pointer(nullTerminatedCString))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringAvailableStringEncodings() *NSStringEncoding { + ret := (*NSStringEncoding)(unsafe.Pointer(C.NSString_AvailableStringEncodings())) + return ret +} + +func NSStringInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSString_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_String()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithCStringEncoding(cString *Char, enc NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithCStringEncoding(unsafe.Pointer(cString), (C.NSStringEncoding)(enc))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringConformsToProtocol(protocol Protocol) bool { + ret := (C.NSString_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSStringAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSString_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func NSStringItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility { + ret := (NSItemProviderRepresentationVisibility)(C.NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier.Ptr())) + return ret +} + +func NSStringWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncoding(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncoding(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncodingError(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncodingError(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringClass() Class { + ret := (Class)(unsafe.Pointer(C.NSString_Class())) + return ret +} + +func NSStringAccessInstanceVariablesDirectly() bool { + ret := (C.NSString_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSStringClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSString_ClassForKeyedUnarchiver())) + return ret +} + +func NSStringVersion() NSInteger { + ret := (NSInteger)(C.NSString_Version()) + return ret +} + +func NSStringResolveClassMethod(sel SEL) bool { + ret := (C.NSString_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSStringDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringSetVersion(aVersion NSInteger) { + C.NSString_SetVersion((C.NSInteger)(aVersion)) +} + +func NSStringDefaultCStringEncoding() NSStringEncoding { + ret := (NSStringEncoding)(C.NSString_DefaultCStringEncoding()) + return ret +} + +func NSStringWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncoding(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncoding(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncodingError(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice2[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncodingError(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice2[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringPathWithComponents(components *NSArray) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_PathWithComponents(components.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringResolveInstanceMethod(sel SEL) bool { + ret := (C.NSString_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSStringIsSubclassOfClass(aClass Class) bool { + ret := (C.NSString_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSStringAllocWithZone(zone *_NSZone) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringObjectWithItemProviderDataTypeIdentifier(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice2[i] = (*outError)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifier(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice2[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + return ret +} + +func NSStringObjectWithItemProviderDataTypeIdentifierError(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString { + + goSlice2 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice2[i] = (*outError)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifierError(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])))) + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice2[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice2[i] + } + if ret.ptr == nil { return ret } + return ret +} + +func NSStringWithString(string *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithString(string.Ptr())) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithGoString(string string) *NSString { + string_chr := CharWithGoString(string) + defer string_chr.Free() + ret := NSStringWithString(NSStringWithUTF8String(string_chr)) + return ret +} + +func NSStringAlloc() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func (o *NSString) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSStringReadableTypeIdentifiersForItemProvider() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_ReadableTypeIdentifiersForItemProvider()) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSStringSupportsSecureCoding() bool { + ret := (C.NSString_SupportsSecureCoding()) != 0 + return ret +} + +func NSStringWithFormat(format *NSString, objects ...NSObject) *NSString { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithFormat(format.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringWithCharactersLength(characters *Unichar, length NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_StringWithCharactersLength(unsafe.Pointer(characters), (C.NSUInteger)(length))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + return ret +} + +func NSStringLocalizedNameOfStringEncoding(encoding NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_LocalizedNameOfStringEncoding((C.NSStringEncoding)(encoding))) + if ret.ptr == nil { return ret } + return ret +} + +func NSStringEncodingForDataEncodingOptions(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding { + + goSlice2 := make([]unsafe.Pointer,cap(*string)) + for i := 0; i < len(*string); i++ { + goSlice2[i] = (*string)[i].Ptr() + } + ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptions(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion))) + (*string) = (*string)[:cap(*string)] + for i := 0; i < len(*string); i++ { + if goSlice2[i] == nil { + (*string) = (*string)[:i] + break + } + if (*string)[i] == nil { + (*string)[i] = &NSString{} + runtime.SetFinalizer((*string)[i], func(o *NSString) { + o.Release() + }) + } + (*string)[i].ptr = goSlice2[i] + } + return ret +} + +func NSStringEncodingForDataEncodingOptionsConvertedString(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding { + + goSlice2 := make([]unsafe.Pointer,cap(*string)) + for i := 0; i < len(*string); i++ { + goSlice2[i] = (*string)[i].Ptr() + } + ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptionsConvertedString(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion))) + (*string) = (*string)[:cap(*string)] + for i := 0; i < len(*string); i++ { + if goSlice2[i] == nil { + (*string) = (*string)[:i] + break + } + if (*string)[i] == nil { + (*string)[i] = &NSString{} + runtime.SetFinalizer((*string)[i], func(o *NSString) { + o.Release() + }) + } + (*string)[i].ptr = goSlice2[i] + } + return ret +} + +func (o *NSString) Hash() NSUInteger { + ret := (NSUInteger)(C.NSString_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CapitalizedStringWithLocale(locale *NSLocale) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedStringWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedStandardRangeOfString(str *NSString) NSRange { + ret := (NSRange)(C.NSString_inst_LocalizedStandardRangeOfString(o.Ptr(), str.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DecomposedStringWithCompatibilityMapping() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCompatibilityMapping(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByDeletingLastPathComponent() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingLastPathComponent(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByAppendingPathComponent(str *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathComponent(o.Ptr(), str.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSString_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSString) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSString_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSString) SmallestEncoding() NSStringEncoding { + ret := (NSStringEncoding)(C.NSString_inst_SmallestEncoding(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedUppercaseString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedUppercaseString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) VariantFittingPresentationWidth(width NSInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_VariantFittingPresentationWidth(o.Ptr(), (C.NSInteger)(width))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfComposedCharacterSequencesForRange(range_ NSRange) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequencesForRange(o.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsLike(object *NSString) bool { + ret := (C.NSString_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSString_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSString_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSString_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) BoolValue() bool { + ret := (C.NSString_inst_BoolValue(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByResolvingSymlinksInPath() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByResolvingSymlinksInPath(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithCharactersNoCopyLength(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithCharactersNoCopyLengthFreeWhenDone(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithUTF8String(nullTerminatedCString *Char) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithUTF8String(o.Ptr(), unsafe.Pointer(nullTerminatedCString))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSString_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsNotEqualTo(object NSObject) bool { + ret := (C.NSString_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSString_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSString_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSString_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSString_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSString_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSString_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSString_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSString_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByDeletingPathExtension() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingPathExtension(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetCStringMaxLength(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool { + ret := (C.NSString_inst_GetCStringMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetCStringMaxLengthEncoding(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool { + ret := (C.NSString_inst_GetCStringMaxLengthEncoding(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Autorelease() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableCopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) UTF8String() *Char { + ret := (*Char)(unsafe.Pointer(C.NSString_inst_UTF8String(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSString_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSString) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSString_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSString) DidChangeValueForKey(key *NSString) { + C.NSString_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSString_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSString_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) StringByPaddingToLengthWithString(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithString(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByPaddingToLengthWithStringStartingAtIndex(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithStringStartingAtIndex(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSString_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSString_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringsByAppendingPaths(paths *NSArray) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringsByAppendingPaths(o.Ptr(), paths.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetLineStartEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { + C.NSString_inst_GetLineStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSString) GetLineStartEndContentsEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { + C.NSString_inst_GetLineStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSString) HasSuffix(str *NSString) bool { + ret := (C.NSString_inst_HasSuffix(o.Ptr(), str.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DoesNotRecognizeSelector(aSelector SEL) { + C.NSString_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSString) LocalizedStandardContainsString(str *NSString) bool { + ret := (C.NSString_inst_LocalizedStandardContainsString(o.Ptr(), str.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSString_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LowercaseStringWithLocale(locale *NSLocale) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseStringWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSString_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) CharacterAtIndex(index NSUInteger) Unichar { + ret := (Unichar)(C.NSString_inst_CharacterAtIndex(o.Ptr(), (C.NSUInteger)(index))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LowercaseString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { + + goSlice4 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice4[i] = (*error)[i].Ptr() + } + ret := (C.NSString_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice4[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice4[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WriteToFileAtomicallyEncoding(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { + + goSlice4 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice4[i] = (*error)[i].Ptr() + } + ret := (C.NSString_inst_WriteToFileAtomicallyEncoding(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice4[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice4[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.NSString_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) HasPrefix(str *NSString) bool { + ret := (C.NSString_inst_HasPrefix(o.Ptr(), str.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PropertyListFromStringsFileFormat() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyListFromStringsFileFormat(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSString_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncoding(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncoding(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncodingError(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncodingError(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByStandardizingPath() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByStandardizingPath(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSString_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSString) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedLowercaseString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedLowercaseString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithDataEncoding(data *NSData, encoding NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithDataEncoding(o.Ptr(), data.Ptr(), (C.NSStringEncoding)(encoding))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) UppercaseStringWithLocale(locale *NSLocale) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseStringWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsKindOfClass(aClass Class) bool { + ret := (C.NSString_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithCStringEncoding(nullTerminatedCString *Char, encoding NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCStringEncoding(o.Ptr(), unsafe.Pointer(nullTerminatedCString), (C.NSStringEncoding)(encoding))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSString_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByReplacingCharactersInRangeWithString(range_ NSRange, replacement *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingCharactersInRangeWithString(o.Ptr(), (C.NSRange)(range_), replacement.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RespondsToSelector(aSelector SEL) bool { + ret := (C.NSString_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSString_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSString_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) FastestEncoding() NSStringEncoding { + ret := (NSStringEncoding)(C.NSString_inst_FastestEncoding(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CommonPrefixWithStringOptions(str *NSString, mask NSStringCompareOptions) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CommonPrefixWithStringOptions(o.Ptr(), str.Ptr(), (C.NSStringCompareOptions)(mask))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CommonPrefixWithStringOGoString(str string, mask NSStringCompareOptions) *NSString { + str_chr := CharWithGoString(str) + defer str_chr.Free() + ret := o.CommonPrefixWithStringOptions(NSStringWithUTF8String(str_chr), mask) + return ret +} + +func (o *NSString) RangeOfString(searchString *NSString) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfString(o.Ptr(), searchString.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfStringOptions(searchString *NSString, mask NSStringCompareOptions) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfStringOptions(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfStringOptionsRange(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRange(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfStringOptionsRangeLocale(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange, locale *NSLocale) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRangeLocale(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch), locale.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LinguisticTagsInRangeScheme(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray { + + goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges)) + for i := 0; i < len(*tokenRanges); i++ { + goSlice5[i] = (*tokenRanges)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeScheme(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0])))) + (*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)] + for i := 0; i < len(*tokenRanges); i++ { + if goSlice5[i] == nil { + (*tokenRanges) = (*tokenRanges)[:i] + break + } + if (*tokenRanges)[i] == nil { + (*tokenRanges)[i] = &NSArray{} + runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) { + o.Release() + }) + } + (*tokenRanges)[i].ptr = goSlice5[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LinguisticTagsInRangeSchemeOptions(range_ NSRange, scheme NSLinguisticTagScheme, options NSLinguisticTaggerOptions, orthography *NSOrthography, tokenRanges *[]*NSArray) *NSArray { + + goSlice5 := make([]unsafe.Pointer,cap(*tokenRanges)) + for i := 0; i < len(*tokenRanges); i++ { + goSlice5[i] = (*tokenRanges)[i].Ptr() + } + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LinguisticTagsInRangeSchemeOptions(o.Ptr(), (C.NSRange)(range_), scheme.Ptr(), (C.NSLinguisticTaggerOptions)(options), orthography.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice5[0])))) + (*tokenRanges) = (*tokenRanges)[:cap(*tokenRanges)] + for i := 0; i < len(*tokenRanges); i++ { + if goSlice5[i] == nil { + (*tokenRanges) = (*tokenRanges)[:i] + break + } + if (*tokenRanges)[i] == nil { + (*tokenRanges)[i] = &NSArray{} + runtime.SetFinalizer((*tokenRanges)[i], func(o *NSArray) { + o.Release() + }) + } + (*tokenRanges)[i].ptr = goSlice5[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PropertyList() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyList(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncoding(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncoding(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncodingError(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString { + + goSlice3 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice3[i] = (*error)[i].Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncodingError(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice3[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice3[i] + } + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByApplyingTransformReverse(transform NSStringTransform, reverse BOOL) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByApplyingTransformReverse(o.Ptr(), transform.Ptr(), (C.BOOL)(reverse))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByFoldingWithOptionsLocale(options NSStringCompareOptions, locale *NSLocale) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByFoldingWithOptionsLocale(o.Ptr(), (C.NSStringCompareOptions)(options), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByTrimmingCharactersInSet(set *NSCharacterSet) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByTrimmingCharactersInSet(o.Ptr(), set.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SetNilValueForKey(key *NSString) { + C.NSString_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) Self() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CapitalizedString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LongLongValue() LongLong { + ret := (LongLong)(C.NSString_inst_LongLongValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Dealloc() { + C.NSString_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) RetainCount() NSUInteger { + ret := (NSUInteger)(C.NSString_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CompletePathIntoStringCaseSensitive(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger { + + goSlice1 := make([]unsafe.Pointer,cap(*outputName)) + for i := 0; i < len(*outputName); i++ { + goSlice1[i] = (*outputName)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outputArray)) + for i := 0; i < len(*outputArray); i++ { + goSlice3[i] = (*outputArray)[i].Ptr() + } + ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitive(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr())) + (*outputName) = (*outputName)[:cap(*outputName)] + for i := 0; i < len(*outputName); i++ { + if goSlice1[i] == nil { + (*outputName) = (*outputName)[:i] + break + } + if (*outputName)[i] == nil { + (*outputName)[i] = &NSString{} + runtime.SetFinalizer((*outputName)[i], func(o *NSString) { + o.Release() + }) + } + (*outputName)[i].ptr = goSlice1[i] + } + (*outputArray) = (*outputArray)[:cap(*outputArray)] + for i := 0; i < len(*outputArray); i++ { + if goSlice3[i] == nil { + (*outputArray) = (*outputArray)[:i] + break + } + if (*outputArray)[i] == nil { + (*outputArray)[i] = &NSArray{} + runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) { + o.Release() + }) + } + (*outputArray)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CompletePathIntoStringCaseSensitiveMatchesIntoArray(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger { + + goSlice1 := make([]unsafe.Pointer,cap(*outputName)) + for i := 0; i < len(*outputName); i++ { + goSlice1[i] = (*outputName)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outputArray)) + for i := 0; i < len(*outputArray); i++ { + goSlice3[i] = (*outputArray)[i].Ptr() + } + ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr())) + (*outputName) = (*outputName)[:cap(*outputName)] + for i := 0; i < len(*outputName); i++ { + if goSlice1[i] == nil { + (*outputName) = (*outputName)[:i] + break + } + if (*outputName)[i] == nil { + (*outputName)[i] = &NSString{} + runtime.SetFinalizer((*outputName)[i], func(o *NSString) { + o.Release() + }) + } + (*outputName)[i].ptr = goSlice1[i] + } + (*outputArray) = (*outputArray)[:cap(*outputArray)] + for i := 0; i < len(*outputArray); i++ { + if goSlice3[i] == nil { + (*outputArray) = (*outputArray)[:i] + break + } + if (*outputArray)[i] == nil { + (*outputArray)[i] = &NSArray{} + runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) { + o.Release() + }) + } + (*outputArray)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Length() NSUInteger { + ret := (NSUInteger)(C.NSString_inst_Length(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByAppendingFormat(format *NSString, objects ...NSObject) *NSString { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility { + ret := (NSItemProviderRepresentationVisibility)(C.NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(o.Ptr(), typeIdentifier.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetBytesMaxLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool { + ret := (C.NSString_inst_GetBytesMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetBytesMaxLengthUsedLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool { + ret := (C.NSString_inst_GetBytesMaxLengthUsedLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByAbbreviatingWithTildeInPath() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAbbreviatingWithTildeInPath(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ParagraphRangeForRange(range_ NSRange) NSRange { + ret := (NSRange)(C.NSString_inst_ParagraphRangeForRange(o.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedCompare(string *NSString) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_LocalizedCompare(o.Ptr(), string.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ComponentsSeparatedByString(separator *NSString) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByString(o.Ptr(), separator.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CaseInsensitiveCompare(string *NSString) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_CaseInsensitiveCompare(o.Ptr(), string.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetParagraphStartEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { + C.NSString_inst_GetParagraphStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSString) GetParagraphStartEndContentsEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange) { + C.NSString_inst_GetParagraphStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSString) Compare(string *NSString) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_Compare(o.Ptr(), string.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CompareOptions(string *NSString, mask NSStringCompareOptions) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_CompareOptions(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CompareOptionsRange(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRange(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CompareOptionsRangeLocale(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange, locale NSObject) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRangeLocale(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare), locale.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfComposedCharacterSequenceAtIndex(index NSUInteger) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequenceAtIndex(o.Ptr(), (C.NSUInteger)(index))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DecomposedStringWithCanonicalMapping() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCanonicalMapping(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithBytesNoCopyLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithBytesNoCopyLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLengthEncoding(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger { + ret := (NSUInteger)(C.NSString_inst_LengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSString_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSString) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSString_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WillChangeValueForKey(key *NSString) { + C.NSString_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSString_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CStringUsingEncoding(encoding NSStringEncoding) *Char { + ret := (*Char)(unsafe.Pointer(C.NSString_inst_CStringUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding)))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedCapitalizedString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedCapitalizedString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DoesContain(object NSObject) bool { + ret := (C.NSString_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByAppendingPathExtension(str *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathExtension(o.Ptr(), str.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DataUsingEncoding(encoding NSStringEncoding) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DataUsingEncodingAllowLossyConversion(encoding NSStringEncoding, lossy BOOL) *NSData { + ret := &NSData{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncodingAllowLossyConversion(o.Ptr(), (C.NSStringEncoding)(encoding), (C.BOOL)(lossy))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSData) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithString(aString *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithString(o.Ptr(), aString.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithGoString(aString string) *NSString { + aString_chr := CharWithGoString(aString) + defer aString_chr.Free() + ret := o.InitWithString(NSStringWithUTF8String(aString_chr)) + return ret +} + +func (o *NSString) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSString_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ContainsString(str *NSString) bool { + ret := (C.NSString_inst_ContainsString(o.Ptr(), str.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsProxy() bool { + ret := (C.NSString_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSString_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LastPathComponent() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_LastPathComponent(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsMemberOfClass(aClass Class) bool { + ret := (C.NSString_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ComponentsSeparatedByCharactersInSet(separator *NSCharacterSet) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByCharactersInSet(o.Ptr(), separator.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SubstringFromIndex(from NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringFromIndex(o.Ptr(), (C.NSUInteger)(from))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithCharactersLength(characters *Unichar, length NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByReplacingOccurrencesOfStringWithString(target *NSString, replacement *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithString(o.Ptr(), target.Ptr(), replacement.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptions(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptionsRange(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetCharacters(buffer *Unichar) { + C.NSString_inst_GetCharacters(o.Ptr(), unsafe.Pointer(buffer)) + runtime.KeepAlive(o) +} + +func (o *NSString) GetCharactersRange(buffer *Unichar, range_ NSRange) { + C.NSString_inst_GetCharactersRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_)) + runtime.KeepAlive(o) +} + +func (o *NSString) Retain() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSString_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSString_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) InitWithCoder(aDecoder *NSCoder) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DoubleValue() Double { + ret := (Double)(C.NSString_inst_DoubleValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LineRangeForRange(range_ NSRange) NSRange { + ret := (NSRange)(C.NSString_inst_LineRangeForRange(o.Ptr(), (C.NSRange)(range_))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSString_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSString_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ScriptingContains(object NSObject) bool { + ret := (C.NSString_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IntegerValue() NSInteger { + ret := (NSInteger)(C.NSString_inst_IntegerValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WriteToURLAtomically(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { + + goSlice4 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice4[i] = (*error)[i].Ptr() + } + ret := (C.NSString_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice4[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice4[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WriteToURLAtomicallyEncoding(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool { + + goSlice4 := make([]unsafe.Pointer,cap(*error)) + for i := 0; i < len(*error); i++ { + goSlice4[i] = (*error)[i].Ptr() + } + ret := (C.NSString_inst_WriteToURLAtomicallyEncoding(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0])))) != 0 + (*error) = (*error)[:cap(*error)] + for i := 0; i < len(*error); i++ { + if goSlice4[i] == nil { + (*error) = (*error)[:i] + break + } + if (*error)[i] == nil { + (*error)[i] = &NSError{} + runtime.SetFinalizer((*error)[i], func(o *NSError) { + o.Release() + }) + } + (*error)[i].ptr = goSlice4[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsAbsolutePath() bool { + ret := (C.NSString_inst_IsAbsolutePath(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsEqualTo(object NSObject) bool { + ret := (C.NSString_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PrecomposedStringWithCanonicalMapping() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCanonicalMapping(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsLessThan(object NSObject) bool { + ret := (C.NSString_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SubstringToIndex(to NSUInteger) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringToIndex(o.Ptr(), (C.NSUInteger)(to))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CopyWithZone(zone *NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PrecomposedStringWithCompatibilityMapping() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCompatibilityMapping(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetFileSystemRepresentationMaxLength(cname *Char, max NSUInteger) bool { + ret := (C.NSString_inst_GetFileSystemRepresentationMaxLength(o.Ptr(), unsafe.Pointer(cname), (C.NSUInteger)(max))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) PathExtension() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PathExtension(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.NSString_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) WritableTypeIdentifiersForItemProvider() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_WritableTypeIdentifiersForItemProvider(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MaximumLengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger { + ret := (NSUInteger)(C.NSString_inst_MaximumLengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SetValueForKey(value NSObject, key *NSString) { + C.NSString_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSString_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSString_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) UppercaseString() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseString(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedCaseInsensitiveCompare(string *NSString) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_LocalizedCaseInsensitiveCompare(o.Ptr(), string.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Release() { + C.NSString_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) PathComponents() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_PathComponents(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByAddingPercentEncodingWithAllowedCharacters(allowedCharacters *NSCharacterSet) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(o.Ptr(), allowedCharacters.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSString_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) StringByAppendingString(aString *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingString(o.Ptr(), aString.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) FloatValue() Float { + ret := (Float)(C.NSString_inst_FloatValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) FileSystemRepresentation() *Char { + ret := (*Char)(unsafe.Pointer(C.NSString_inst_FileSystemRepresentation(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByExpandingTildeInPath() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByExpandingTildeInPath(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsEqual(object NSObject) bool { + ret := (C.NSString_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) StringByRemovingPercentEncoding() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_StringByRemovingPercentEncoding(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.NSString_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSString_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) InitWithFormat(format *NSString, objects ...NSObject) *NSString { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormat(o.Ptr(), format.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithFormatLocale(format *NSString, locale NSObject, objects ...NSObject) *NSString { + var object [16]unsafe.Pointer + for i,o := range objects { + object[i] = o.Ptr() + } + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatLocale(o.Ptr(), format.Ptr(), locale.Ptr(), unsafe.Pointer(&object))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedCaseInsensitiveContainsString(str *NSString) bool { + ret := (C.NSString_inst_LocalizedCaseInsensitiveContainsString(o.Ptr(), str.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsGreaterThan(object NSObject) bool { + ret := (C.NSString_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Init() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) CanBeConvertedToEncoding(encoding NSStringEncoding) bool { + ret := (C.NSString_inst_CanBeConvertedToEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IsEqualToString(aString *NSString) bool { + ret := (C.NSString_inst_IsEqualToString(o.Ptr(), aString.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSString_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) LocalizedStandardCompare(string *NSString) NSComparisonResult { + ret := (NSComparisonResult)(C.NSString_inst_LocalizedStandardCompare(o.Ptr(), string.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSString_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSString_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSString) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSString_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) IntValue() Int { + ret := (Int)(C.NSString_inst_IntValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.NSString_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSString_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSString_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSString_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSString) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSString_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfCharacterFromSet(searchSet *NSCharacterSet) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSet(o.Ptr(), searchSet.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfCharacterFromSetOptions(searchSet *NSCharacterSet, mask NSStringCompareOptions) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptions(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) RangeOfCharacterFromSetOptionsRange(searchSet *NSCharacterSet, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange { + ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptionsRange(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithBytesLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) InitWithBytesLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLengthEncoding(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) SubstringWithRange(range_ NSRange) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringWithRange(o.Ptr(), (C.NSRange)(range_))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSString) ForwardInvocation(anInvocation *NSInvocation) { + C.NSString_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func NSNumberValueWithNonretainedObject(anObject NSObject) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithNonretainedObject(anObject.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberNew() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_New()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet { + ret := &NSSet{} + ret.ptr = unsafe.Pointer(C.NSNumber_KeyPathsForValuesAffectingValueForKey(key.Ptr())) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberCancelPreviousPerformRequestsWithTarget(aTarget NSObject) { + C.NSNumber_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr()) +} + +func NSNumberCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSNumber_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSNumberCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject) { + C.NSNumber_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr()) +} + +func NSNumberWithFloat(value Float) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithFloat((C.float)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithDouble(value Double) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithDouble((C.double)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithChar(value Char) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithChar((C.char)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberValueWithRect(rect NSRect) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRect((C.NSRect)(rect))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberAllocWithZone(zone *_NSZone) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_AllocWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_Description()) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberLoad() { + C.NSNumber_Load() +} + +func NSNumberDebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_DebugDescription()) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberSuperclass() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_Superclass())) + return ret +} + +func NSNumberWithInt(value Int) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInt((C.int)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithShort(value Short) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithShort((C.short)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberValueWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithBytesObjCType(unsafe.Pointer(value), unsafe.Pointer(type_))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberResolveClassMethod(sel SEL) bool { + ret := (C.NSNumber_ResolveClassMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSNumberClassFallbacksForKeyedArchiver() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_ClassFallbacksForKeyedArchiver()) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberConformsToProtocol(protocol Protocol) bool { + ret := (C.NSNumber_ConformsToProtocol(protocol.Ptr())) != 0 + return ret +} + +func NSNumberHash() NSUInteger { + ret := (NSUInteger)(C.NSNumber_Hash()) + return ret +} + +func NSNumberWithUnsignedInt(value UnsignedInt) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInt((C.uint)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithUnsignedInteger(value NSUInteger) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInteger((C.NSUInteger)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithUnsignedLong(value UnsignedLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLong((C.ulong)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithUnsignedChar(value UnsignedChar) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedChar((C.uchar)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSNumber_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberWithUnsignedLongLong(value UnsignedLongLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLongLong((C.ulonglong)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithUnsignedShort(value UnsignedShort) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedShort((C.ushort)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberMutableCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_MutableCopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSNumberInstancesRespondToSelector(aSelector SEL) bool { + ret := (C.NSNumber_InstancesRespondToSelector(unsafe.Pointer(aSelector))) != 0 + return ret +} + +func NSNumberClassForKeyedUnarchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_ClassForKeyedUnarchiver())) + return ret +} + +func NSNumberIsSubclassOfClass(aClass Class) bool { + ret := (C.NSNumber_IsSubclassOfClass(unsafe.Pointer(aClass))) != 0 + return ret +} + +func NSNumberValueWithPoint(point NSPoint) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPoint((C.NSPoint)(point))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberValueWithObjCType(value unsafe.Pointer, type_ *Char) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithObjCType(unsafe.Pointer(value), unsafe.Pointer(type_))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberValueWithRange(range_ NSRange) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRange((C.NSRange)(range_))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberVersion() NSInteger { + ret := (NSInteger)(C.NSNumber_Version()) + return ret +} + +func NSNumberAlloc() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_Alloc()) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func (o *NSNumber) GC() { + if o.ptr == nil { return } + runtime.SetFinalizer(o, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) +} + +func NSNumberResolveInstanceMethod(sel SEL) bool { + ret := (C.NSNumber_ResolveInstanceMethod(unsafe.Pointer(sel))) != 0 + return ret +} + +func NSNumberWithInteger(value NSInteger) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInteger((C.NSInteger)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberWithBool(value BOOL) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithBool((C.BOOL)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberClass() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_Class())) + return ret +} + +func NSNumberCopyWithZone(zone *_NSZone) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_CopyWithZone(unsafe.Pointer(zone))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + return ret +} + +func NSNumberWithLong(value Long) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLong((C.long)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberValueWithSize(size NSSize) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithSize((C.NSSize)(size))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberValueWithEdgeInsets(insets NSEdgeInsets) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithEdgeInsets((C.NSEdgeInsets)(insets))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberSetVersion(aVersion NSInteger) { + C.NSNumber_SetVersion((C.NSInteger)(aVersion)) +} + +func NSNumberWithLongLong(value LongLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLongLong((C.longlong)(value))) + if ret.ptr == nil { return ret } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + return ret +} + +func NSNumberValueWithPointer(pointer unsafe.Pointer) *NSValue { + ret := &NSValue{} + ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPointer(unsafe.Pointer(pointer))) + if ret.ptr == nil { return ret } + return ret +} + +func NSNumberAccessInstanceVariablesDirectly() bool { + ret := (C.NSNumber_AccessInstanceVariablesDirectly()) != 0 + return ret +} + +func NSNumberAutomaticallyNotifiesObserversForKey(key *NSString) bool { + ret := (C.NSNumber_AutomaticallyNotifiesObserversForKey(key.Ptr())) != 0 + return ret +} + +func (o *NSNumber) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSNumber_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer) { + C.NSNumber_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) MutableArrayValueForKey(key *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingIsEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValueForKeyPath(keyPath *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingIsGreaterThan(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) UnsignedCharValue() UnsignedChar { + ret := (UnsignedChar)(C.NSNumber_inst_UnsignedCharValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) RetainCount() NSUInteger { + ret := (NSUInteger)(C.NSNumber_inst_RetainCount(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) StringValue() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_StringValue(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValueForKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) SetObservationInfo(observationInfo unsafe.Pointer) { + C.NSNumber_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL) { + C.NSNumber_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL) { + C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray) { + C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithInteger(value NSInteger) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInteger(o.Ptr(), (C.NSInteger)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithFloat(value Float) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithFloat(o.Ptr(), (C.float)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) RectValue() NSRect { + ret := (NSRect)(C.NSNumber_inst_RectValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSNumber_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer) { + C.NSNumber_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) DebugDescription() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_DebugDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PerformSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval) { + C.NSNumber_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSNumber_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray) { + C.NSNumber_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL) { + C.NSNumber_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray) { + C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSNumber_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSNumber_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ScriptingBeginsWith(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Compare(otherNumber *NSNumber) NSComparisonResult { + ret := (NSComparisonResult)(C.NSNumber_inst_Compare(o.Ptr(), otherNumber.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsEqualToNumber(number *NSNumber) bool { + ret := (C.NSNumber_inst_IsEqualToNumber(o.Ptr(), number.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBytesObjCType(o.Ptr(), unsafe.Pointer(value), unsafe.Pointer(type_))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ReplacementObjectForCoder(aCoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForCoder(o.Ptr(), aCoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ToManyRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToManyRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ForwardInvocation(anInvocation *NSInvocation) { + C.NSNumber_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithUnsignedChar(value UnsignedChar) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedChar(o.Ptr(), (C.uchar)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithChar(value Char) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithChar(o.Ptr(), (C.char)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) UnsignedIntegerValue() NSUInteger { + ret := (NSUInteger)(C.NSNumber_inst_UnsignedIntegerValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSNumber_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString) { + C.NSNumber_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithInt(value Int) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInt(o.Ptr(), (C.int)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) UnsignedLongLongValue() UnsignedLongLong { + ret := (UnsignedLongLong)(C.NSNumber_inst_UnsignedLongLongValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingIsLessThan(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Description() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Description(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithLong(value Long) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLong(o.Ptr(), (C.long)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) UnsignedIntValue() UnsignedInt { + ret := (UnsignedInt)(C.NSNumber_inst_UnsignedIntValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PointValue() NSPoint { + ret := (NSPoint)(C.NSNumber_inst_PointValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool { + ret := (C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer) { + C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject) { + C.NSNumber_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsGreaterThan(object NSObject) bool { + ret := (C.NSNumber_inst_IsGreaterThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Release() { + C.NSNumber_inst_Release(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithUnsignedInt(value UnsignedInt) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInt(o.Ptr(), (C.uint)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DoubleValue() Double { + ret := (Double)(C.NSNumber_inst_DoubleValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsKindOfClass(aClass Class) bool { + ret := (C.NSNumber_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ClassName() *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassName(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) SetNilValueForKey(key *NSString) { + C.NSNumber_inst_SetNilValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray { + ret := &NSMutableArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ForwardingTargetForSelector(aSelector SEL) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DoesContain(object NSObject) bool { + ret := (C.NSNumber_inst_DoesContain(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) SetScriptingProperties(scriptingProperties *NSDictionary) { + C.NSNumber_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) CoerceValueForKey(value NSObject, key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsCaseInsensitiveLike(object *NSString) bool { + ret := (C.NSNumber_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ClassCode() FourCharCode { + ret := (FourCharCode)(C.NSNumber_inst_ClassCode(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithUnsignedInteger(value NSUInteger) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInteger(o.Ptr(), (C.NSUInteger)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ObjCType() *Char { + ret := (*Char)(unsafe.Pointer(C.NSNumber_inst_ObjCType(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsEqualToValue(value *NSValue) bool { + ret := (C.NSNumber_inst_IsEqualToValue(o.Ptr(), value.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InverseForRelationshipKey(relationshipKey *NSString) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IntValue() Int { + ret := (Int)(C.NSNumber_inst_IntValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsNotEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_IsNotEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsProxy() bool { + ret := (C.NSNumber_inst_IsProxy(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Init() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Init(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsMemberOfClass(aClass Class) bool { + ret := (C.NSNumber_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature { + ret := &NSMethodSignature{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMethodSignature) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) AwakeAfterUsingCoder(aDecoder *NSCoder) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_AwakeAfterUsingCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ConformsToProtocol(aProtocol Protocol) bool { + ret := (C.NSNumber_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValueForUndefinedKey(key *NSString) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet { + ret := &NSMutableOrderedSet{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithUnsignedShort(value UnsignedShort) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedShort(o.Ptr(), (C.ushort)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) UnsignedShortValue() UnsignedShort { + ret := (UnsignedShort)(C.NSNumber_inst_UnsignedShortValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Autorelease() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Autorelease(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Superclass() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Superclass(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingContains(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingContains(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSNumber_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSNumber_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSNumber_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool { + + goSlice1 := make([]unsafe.Pointer,cap(*ioValue)) + for i := 0; i < len(*ioValue); i++ { + goSlice1[i] = (*ioValue)[i].Ptr() + } + + goSlice3 := make([]unsafe.Pointer,cap(*outError)) + for i := 0; i < len(*outError); i++ { + goSlice3[i] = (*outError)[i].Ptr() + } + ret := (C.NSNumber_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])))) != 0 + (*ioValue) = (*ioValue)[:cap(*ioValue)] + for i := 0; i < len(*ioValue); i++ { + if goSlice1[i] == nil { + (*ioValue) = (*ioValue)[:i] + break + } + if (*ioValue)[i] == nil { + (*ioValue)[i] = &Id{} + runtime.SetFinalizer((*ioValue)[i], func(o *Id) { + o.Release() + }) + } + (*ioValue)[i].ptr = goSlice1[i] + } + (*outError) = (*outError)[:cap(*outError)] + for i := 0; i < len(*outError); i++ { + if goSlice3[i] == nil { + (*outError) = (*outError)[:i] + break + } + if (*outError)[i] == nil { + (*outError)[i] = &NSError{} + runtime.SetFinalizer((*outError)[i], func(o *NSError) { + o.Release() + }) + } + (*outError)[i].ptr = goSlice3[i] + } + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsEqual(object NSObject) bool { + ret := (C.NSNumber_inst_IsEqual(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) FloatValue() Float { + ret := (Float)(C.NSNumber_inst_FloatValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithCoder(aDecoder *NSCoder) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithCoder(o.Ptr(), aDecoder.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) NonretainedObjectValue() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_NonretainedObjectValue(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) SizeValue() NSSize { + ret := (NSSize)(C.NSNumber_inst_SizeValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsLike(object *NSString) bool { + ret := (C.NSNumber_inst_IsLike(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) AutoContentAccessingProxy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_AutoContentAccessingProxy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ShortValue() Short { + ret := (Short)(C.NSNumber_inst_ShortValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DescriptionWithLocale(locale NSObject) *NSString { + ret := &NSString{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSString) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ClassForArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) WillChangeValueForKey(key *NSString) { + C.NSNumber_inst_WillChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSNumber_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSNumber_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) Self() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Self(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) LongLongValue() LongLong { + ret := (LongLong)(C.NSNumber_inst_LongLongValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IntegerValue() NSInteger { + ret := (NSInteger)(C.NSNumber_inst_IntegerValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DidChangeValueForKey(key *NSString) { + C.NSNumber_inst_DidChangeValueForKey(o.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSNumber_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet) { + C.NSNumber_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithLongLong(value LongLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLongLong(o.Ptr(), (C.longlong)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithUnsignedLong(value UnsignedLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLong(o.Ptr(), (C.ulong)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) EdgeInsetsValue() NSEdgeInsets { + ret := (NSEdgeInsets)(C.NSNumber_inst_EdgeInsetsValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString) { + C.NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) UnsignedLongValue() UnsignedLong { + ret := (UnsignedLong)(C.NSNumber_inst_UnsignedLongValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) LongValue() Long { + ret := (Long)(C.NSNumber_inst_LongValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingIsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString) { + C.NSNumber_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer) { + C.NSNumber_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) SetValueForKey(value NSObject, key *NSString) { + C.NSNumber_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) SetValueForKeyPath(value NSObject, keyPath *NSString) { + C.NSNumber_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) SetValueForUndefinedKey(value NSObject, key *NSString) { + C.NSNumber_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InitWithShort(value Short) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithShort(o.Ptr(), (C.short)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Copy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Copy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ObservationInfo() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_ObservationInfo(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DoesNotRecognizeSelector(aSelector SEL) { + C.NSNumber_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) Zone() *_NSZone { + ret := (*_NSZone)(unsafe.Pointer(C.NSNumber_inst_Zone(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) CharValue() Char { + ret := (Char)(C.NSNumber_inst_CharValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) PointerValue() unsafe.Pointer { + ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_PointerValue(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Hash() NSUInteger { + ret := (NSUInteger)(C.NSNumber_inst_Hash(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithBool(value BOOL) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBool(o.Ptr(), (C.BOOL)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) SetValuesForKeysWithDictionary(keyedValues *NSDictionary) { + C.NSNumber_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) MutableCopy() *Id { + ret := &Id{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableCopy(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + runtime.SetFinalizer(ret, func(o *Id) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ClassForKeyedArchiver() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForKeyedArchiver(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) AttributeKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_AttributeKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) MutableSetValueForKey(key *NSString) *NSMutableSet { + ret := &NSMutableSet{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKey(o.Ptr(), key.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSMutableSet) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Retain() *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_Retain(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) GetClass() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_inst_Class(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ScriptingProperties() *NSDictionary { + ret := &NSDictionary{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingProperties(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSDictionary) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ClassForCoder() Class { + ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForCoder(o.Ptr()))) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ToOneRelationshipKeys() *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToOneRelationshipKeys(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsGreaterThanOrEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithDouble(value Double) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithDouble(o.Ptr(), (C.double)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InitWithUnsignedLongLong(value UnsignedLongLong) *NSNumber { + ret := &NSNumber{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLongLong(o.Ptr(), (C.ulonglong)(value))) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSNumber) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_IsEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ObjectSpecifier() *NSScriptObjectSpecifier { + ret := &NSScriptObjectSpecifier{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ObjectSpecifier(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) Dealloc() { + C.NSNumber_inst_Dealloc(o.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) IsLessThan(object NSObject) bool { + ret := (C.NSNumber_inst_IsLessThan(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject) { + C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject) { + C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) RangeValue() NSRange { + ret := (NSRange)(C.NSNumber_inst_RangeValue(o.Ptr())) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) GetValue(value unsafe.Pointer) { + C.NSNumber_inst_GetValue(o.Ptr(), unsafe.Pointer(value)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) GetValueSize(value unsafe.Pointer, size NSUInteger) { + C.NSNumber_inst_GetValueSize(o.Ptr(), unsafe.Pointer(value), (C.NSUInteger)(size)) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ClassDescription() *NSClassDescription { + ret := &NSClassDescription{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassDescription(o.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSClassDescription) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) InsertValueInPropertyWithKey(value NSObject, key *NSString) { + C.NSNumber_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString) { + C.NSNumber_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString) { + C.NSNumber_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr()) + runtime.KeepAlive(o) +} + +func (o *NSNumber) ScriptingEndsWith(object NSObject) bool { + ret := (C.NSNumber_inst_ScriptingEndsWith(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) BoolValue() bool { + ret := (C.NSNumber_inst_BoolValue(o.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) RespondsToSelector(aSelector SEL) bool { + ret := (C.NSNumber_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector))) != 0 + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray { + ret := &NSArray{} + ret.ptr = unsafe.Pointer(C.NSNumber_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr())) + if ret.ptr == nil { runtime.KeepAlive(o); return ret } + if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) } + runtime.SetFinalizer(ret, func(o *NSArray) { + o.Release() + }) + runtime.KeepAlive(o) + return ret +} + +func (o *NSNumber) IsLessThanOrEqualTo(object NSObject) bool { + ret := (C.NSNumber_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr())) != 0 + runtime.KeepAlive(o) + return ret +} + func DispatchQueueCreate(label *Char, attr Dispatch_queue_attr_t) Dispatch_queue_t { ret := &Id{} ret.ptr = unsafe.Pointer(C.dispatch_queue_create((*C.char)(label), (C.dispatch_queue_attr_t)(attr.Ptr()))) @@ -61489,6 +60860,7 @@ func (o *CBDelegate) GC() { type CBDelegateDispatch struct { CentralManagerDidUpdateState func(*CBCentralManager, ) CentralManagerDidConnectPeripheral func(*CBCentralManager, *CBPeripheral, ) + CentralManagerDidDisconnectPeripheral func(*CBCentralManager, *CBPeripheral, *NSError, ) CentralManagerDidDiscoverPeripheral func(*CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber, ) PeripheralDidDiscoverServices func(*CBPeripheral, *NSError, ) PeripheralDidDiscoverCharacteristicsForService func(*CBPeripheral, *CBService, *NSError, ) @@ -61513,6 +60885,14 @@ func (d CBDelegate) CentralManagerDidConnectPeripheralCallback(f func(*CBCentral CBDelegateMux.Unlock() } +func (d CBDelegate) CentralManagerDidDisconnectPeripheralCallback(f func(*CBCentralManager, *CBPeripheral, *NSError, )) { + CBDelegateMux.Lock() + dispatch := CBDelegateLookup[d.Ptr()] + dispatch.CentralManagerDidDisconnectPeripheral = f + CBDelegateLookup[d.Ptr()] = dispatch + CBDelegateMux.Unlock() +} + func (d CBDelegate) CentralManagerDidDiscoverPeripheralCallback(f func(*CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber, )) { CBDelegateMux.Lock() dispatch := CBDelegateLookup[d.Ptr()] @@ -61555,11 +60935,6 @@ func (o *CBDelegate) CentralManagerDidFailToConnectPeripheral(central *CBCentral runtime.KeepAlive(o) } -func (o *CBDelegate) CentralManagerDidDisconnectPeripheral(central *CBCentralManager, peripheral *CBPeripheral, error *NSError) { - C.CBDelegate_inst_CentralManagerDidDisconnectPeripheral(unsafe.Pointer(o), central.Ptr(), peripheral.Ptr(), error.Ptr()) - runtime.KeepAlive(o) -} - func (o *CBDelegate) PeripheralDidUpdateName(peripheral *CBPeripheral) { C.CBDelegate_inst_PeripheralDidUpdateName(unsafe.Pointer(o), peripheral.Ptr()) runtime.KeepAlive(o) diff --git a/nswrap.yaml b/nswrap.yaml index cb9e3c1..445485b 100644 --- a/nswrap.yaml +++ b/nswrap.yaml @@ -35,6 +35,7 @@ delegates: - centralManagerDidUpdateState - centralManagerDidDiscoverPeripheral - centralManagerDidConnectPeripheral + - centralManagerDidDisconnectPeripheral CBPeripheralDelegate: - peripheralDidDiscoverServices - peripheralDidDiscoverCharacteristicsForService