K#e3-v+ֈ)
/zu}&Nfɜ%8QqؽIt.\`cB ѐ[<]CdY\BڵjشGot=
ЍZIաb ʍT h.
r,CP{/T MަKjJΏoBis/$ͱ[Idy:3r]ps
YP.a%1X"@ {We 9xX)z$Z+~DPAg+b
8aHVg攵 r=;L@:4ܢ0fgy&:ʽZXTr ^"2KC Bg84tf3I~Ykyϧ~_cĩwVcGwWW1X[|E;l0>nе#It9g)Z\эQ@Ѥ9gy
)<+Lg$ApB]~xZ;}>rnOwܧܧݧ }5m_OfIc۾kn۾5mlll.o}۾m_{{
_&$[nz/YWX~?D4Uj 7>(=Q>Ly^~w&ğqj`> QTI3~@??& ЮgEyIyҠ+FBV*/_}}m<@lc 鮩r58 c`ӯB&|sꘃ
sB"OrVN+VILHUH/
5> n jEIèq=':<> ]o_(H EG#Ѐ hߞ\M ={.ݒ&^zp f.tu, \\YBpZM3##;LzGXCõp\ nN .L!Ulʦ*@ x
VIɌNf!@%]Z1(Y
@}51{ y*)4Lp2wiYa 4x%>4| b 7F"Vc]e;Ziۿsf(l%Lx2]04c sFy{] |[}r T u侮>5Un'@K څYuM*;~r 'Yua+qO4%5=L";02# l<7g&ΛW.l/
?4 \-ش$ڸvAxq}G\S{@BkS9 /_/
FJ9mG/~fʜ]*(%.J 67!Qqш^e$Q.ꬸ^
4QF|X5ר$kC`Vu9sh7ڿ^aM>)G
np[ H2kT
=Rz``p~{l] 9ƫNag[ `ߥzL;6,W WuvCo9/K d@> R(&ezߏHwӋlvJN hT.jG"\GL q/۟4ZV G}ģcř Db Le [~y+ZRWa
[؍i:8EKE!vsxg~סhPq1Gu|n(53
~ ssX{3IxqTVdz6xI9$lqy5@> ?T`^;Ӯ ,z߱HSn
Lzg)yꗠ.~"Xy}Ǻ3TYvr؇`N-
wnXKn8X|dlPR}9P/w_g Byn u >JEeRࠉz@RW]minl^ˠ |l&hJ F]L1@i+NJaQ;Tz/sTlSݸqQ>|
]J6wE^ +0x~ٱM@2?$[FKAbi %c\_< {~|
pVy"Tqu
/ sߧ7o߾ ɬrosf&{q0+=S@_4=e5aԒ{7@l^C> PKMW{
Wb zLm}m{U (xj&c7`j&팅ޕ7n" ˠdKx6cU 0>
֬.080FD8RgeY
$yrq |ۈExiHмHRjChA0 3j')N`Z*yj N@)!$ZX'ydrj#gd)YFdc4c4> ),IVpi2Z ڭ[VgS>^:dKmTҋ~:z TSe״9vi2 Mf 5a+n6Μl-Ҿzfپzu+nu eȠcafsbh֍7EĔ&tJ5e0t@qnx<;)@
IX9l̾@ m 8laraN_n & -%p`/2UeUBvƑ1A%%ڈ6eeQgN
Bnd k6PQE,]ƽZRېh ʊY~y٧VKn5x睊s89K88 FŸr}~CX,!DSk%߽|ɰ*q5`nChED q_aV8X|0z Ӈ9P3كB#Zg$աAR1D!
uǢ 0=-z
A *솺qNϭH9PHD4շ XSz[K=x4jn^AGr?}3}3;sffK 5}Pv
pչWv'VU5h>mjVPʖ(rjg
J܍V ;!iO&iXE}W@Lu2&nwᤅaG;{
_YVtiQOR:*\z=3<\e\)rr>/^
\,. ߺ&tXM:M-_kbi - P9MY'J
lDZ m6*vkdAf&@^j&<#~sJg8Ȝ@
16_ę! Yd B { mͧZ\agI h Z
j#[ϴWRAjVz݅KT|XPWmWkKѸJ,F]6(^A#J3 vʉu4V5uUN'f74f 3f ]k6 H@:io~JA6t??E~|4~ U^2;&[=o ٜL+f:xG{I"ݍMp3[EƜ\v9xT.W\x;vVfiXL
XˤG FF/HrU Q8g9Czj:A:0?)N\o
C_JŖ OӈN{JK4TOXKУ[l-F^;'b ^d%o-.`@&%'h2\>/Z
L-*5d2}v!ckr~D-.V 8^W' Ht;|zak
A=QZi zQ amǏLLJ/aU#AkX 4O)icJ`PwѸکH]L
xp88=R~(Á H7ǹ;4F6шm0(f*Bԧ A5*R
)>^zy) wv0?m-îp vh?~G=:2ӊsi
Y]xb J3A0 -i:˖ K&Y*5|jO: bCR`^/.<(Xi뭌b.-־j#[]Ӓ33̼4]W_UU9V8lL_$dvEdoW
&+Ѡ>D$9ي=]" GY3$ bV6+L_+0YxGYFOח̯1c9 8.Rmf 3 #("IzL8H}
{ P
DP >*mH {RC[{AQSJȯX#C)?-wLQH~zy
b_,g{UH" BVwuLvqbH;+uw w5e4:,|訨 m:~
4qSRa60S Yѩ <Ά^5 7;Y;| nN) Ւ{J|oCSj b#' TzDMՅlc`&3{5Ϫ ݈w @M3]YL7%!cf:J\w* fљ
8DJ ,ҔpkSkdЦ Vb%;Hl3FI `Ohuz%de`PsDL}Ʃ+b@2X8 `UgL5bC\$==PG> z+;e+|6l.;yɊjs ѽn4tRmZౘ5=On ('
1
LR^k.V0L7MX?!%&ΆIJʗ~%= 0
* ,L"֓uj2h zOe+*s@g@/ji] *ttqs6K̘8yxTtrH&ҭ&ɛ.cӒ"N)ZYZK.)ѥr8_S8,gCܙhHy\8 ') F^iF"ET:cL3K &=/v %LPd K/ , juF-krXVEqfR=T tX$$ .N)7RX_ۢxjZt&4{BM;Xat`Ei捙p6 9'ڏʈWsgiɠn!3R3u ygjk@~ N|;*N:aKp7 Է:ƪzϒNHh?`Z#N4 | P%{;nFWNrh
8T8i{w+\ y2bbZ;,M!Yp6+eӴat^
awjyk=+H j|%$5KtiM8*_%7 'dhоet[e:^4-z2^ݍ)e4p< ϙvlEZ V>2sVIΙφ%
|Xs^q.Ѕ)f s@xJ%D=/ώw# ({X_JDDVœ$+ݟQ+E"|r?{ނMI阍}9z4mh7+"NA6/rȸ5^ݼ; eX:}M^֩`'8Ku ^A
{sKR8!1]Nb 6v:lDg#Po^Q3 RQ+wt]?Nx}S0!@ZN%+wƆH yL7K6!a zoNBT/a.@t% ˋ %U,Èe0\ij+QM+CɆ'3 (,)D+ TokϜ8YJ<>]rOLL@CbwwJQm"9nkcuXVM،Bx[L
}ujM|eg C}IzЮfDau;fd.q e!G}e:M7w3+å1dي5 TBdx[ c Wekˋn'Tx&>Xf5^_ż!7'd
ϡq1 hl.罎 _bw5/d
lƥ'rEPӕprI˶ 軦R` ɍS3hI,J%|n YT+vrvM^ R-% ]5 bf`瀭>敂$F3d0CM)DVyO2i
[ $:F< yݱpGА43 0 p_ aU9EfDz)韙zm
Ib5i>%1 b(00v>'@Ӆ -V $1iG@*# 8: [FYS7xA}>ZuӵAwʽr;5oOrKϡ-0A㘄k.-~I/ο}8H` M QS>L qMD:Oj@x݉kO?Am(#.'o? $jcE#KTNvm6"T\8zqC /0 QS# a-HbGb ؉ٴNBF =YҤIpKTdZ 1Wۻ5M]{]H9φv*V(;4 ?!98VD k+6Ob >t$Y||1%l8BKA}pDQeOWM$1҇{gm%JT W:!rdneQQ C͛ GЫ]-,|@u1 K uA)vy4T
WXp
m v ^d,mp>|d >A jM`YC\|\YD@ .ϫOrXq-*J8ޔ )yQ]90B!B5HJ.YCuSe*S7&-WEKST
C/]Om\Bpciȗi@ޥ=BTklrًj 8Ԃ6jֳ͏_q:dk'3'(Ɛ~]bECVZiS`
Ebp&@Ȫc @WHg!P R
[ŗ::UԘ@D$Rk ̬3ޢծlq9Vyc
ZߣUCzr,{Z86%>'3,om %3znKRWn7{?ʄ$ \
U һf89`J
bqͨS}ZjZp< əA
-\bQXmP
|̪q8ph_LHDCFN,-J^8TMjug
L0$X+7Eg>=eC Q/
N .7d8`)zXxF^jdX?EXOR1H9|VXMĿ6{:p cU 45*SF9## 6D3s1G"0VR[1U'SQYDg]t'o8܌cSgzğ[&0LC1ʅ.BKVҬN<*TM*ޱ%fW^v?W穋G΄d\%.xF߄RV^ml,&lYqDX \˦9OJBE~要9*s*Z{Y D+=^X&`b @[uJ%\
-7&|u 4^ RoX̔F 2ވVW|JV1DWB>B@<|T
;(Ysey4`QMgdgkhh3`>;hz M,] w$,$m llו ̭ tp4q-OClR98:A
Y˫ | -)"1F/.kAO
p$ P5DfXLJR| C/O&j
~ko2J"+hOcK n\cc,420-B;ElJ|v&,%Q"?!AyO/얤bȆlyWYzNŴؾu
G&VM醶L6zi-diQ1EGUv+ap鄀9 鮯FofMa^RVL ] -e?º-
"BmF ̜z;
k,e%bF&WXx!6̃M&b7vU[`tB6Oy{fX
2aO biIׯ\5`Fjck[0/??w*)-|TkE]^8 kШS. ӛZ. PyGeHAt
LO1MDn|P`1 E*ܡy+{Ut&E(%+Tk`m|+.7?jXBwl\ ˤlInB}CGTВPuAĻ݇YװihYهe{ϲeY8DT
Vq ƨEiBZBjo3v fb9*
< ̄B2Fcy?xƏK Jz"C ?UxoLtcJ:ҒtuGL4&6 >?1zE}' ={A_<'qv`nEmC&軆s9Hx.jgcTFX~sCiKApQ̀0dI $zG(
ƭ5`|SKuXeMd"~ Bo%1d_7$o)7D`
E<~nmHvugs:e0zh<%o/M8Qr{xx5@*@TS E2 @['Z-ע[?|>V XPoasD14ktQHq۾8F.
us$ܟ$9[Y-2OZ.Vx-)s]J¯%V6
AA7-GpXԼa
t-AZ7Yuuf× 9~{=ZU* %(͚Ʊ$M1j ́6g(Ar0q -+!
x٠ 뻫WA+bI>z/|?#J哥-LRZ!hvB~): .8$,\4X l`DKJ:
T/⥽jgϜ$Qg,+ w.dWO(WŘVpM .Y 9B&8.ǘ{\RK v.3j:i:( DjCΠͮAE܄"-HLg(Gaz#.?7}v9pB; ʝ!7A bvh->D**.~A)4 \{:8#> r^++sX'mT0E[МP {7*< (8:UÙQS5ku)m thkJtˆb ddl (nC5PY)w09@r c;퀛ΓM=0)AKY >X3;$g\ǃb1c404۹Ӝxq:K%ȓz!^#ՌOo641n)+RcKFgM2᳚sT
դe& 1T G ڍ@\v[^`FoIAV[0NB/Zl% 2z.>6wɯ6)JeZ0$0@D,
-1X՝"_ۄf3eZV H TҪ1㤮7zY iu
)~6yvK!L"7j[acyqLTמ% CʚQ
UB/BlhP)q272aC! oY㷂r8?Z@#дk@p7O
rlC U EM9뽤Kc?IH a7XVJ}2w9{]QۻSmݶ*h#oi.(bM \b-Nxr2
$s>\
E3-yu dr iH)iפVtzH%&Aab}?D}>{քWf>/ޘ{ 5kʊuD"E%Er^ X2 'EǒNF ! Z}[VtympOu(_ ~ݳ|}6ygJ{ rPIrsqv9qzJCfZ'8|65#j :2xʻ̱` Q+=H o
+bjb(*;sBR3Yi?ܙj;Rz8 J 9tбA>1 ԭTG'S !%"DpNmb[HFd٢Aub;
o0iÄ\ۆ ҏo,bI:aZV%% 44?Tvl7[!ͼדBPIڦ_Lm -u S£G`' J ֳ>,g38 ʴá>(.Mv|X:7xW`.V1$ $ ?T> cd~іO0Os)u{| Mm}G^ m.pd$n7QD&%nDƭM45nǍ;Ա&uΪqETu;g -+WLL BJe+zi2 P21Z4>utI2PE\d/&(\ohạ$~]E!# =8 6t:Zޔ+9a&u&@3v
q[4MEPhYz8 ԡE9)5X7c<3D] Vyã[-LSiJ3}J=
I#։ʽn#>gD| gg?͋, 33I
Ӑ$2J[@$$0YQ A
:/k'N!\1gT7$La/uxb꼽z@ԕi
Pڗ
2KKXruC<$բ;C}!gPɡo@ݾESg ߺ+9`eA92zw4Ӫqh
Hf6n92^FHV6tMl*ł{F҂]R /`*No[*1-{rG% =w8Yظ4 f>f\p59\N@!nTcqSA+_p1]@pg??|`ȋǕΖAMܬ4 ʈf@ BgMǃl OAd@ \ fAP t8nҷZsFb:[nw q >}i4V
S\ %-iSoQ=}hoQ6o! ȑ:ĵbqdH.FmuJy=p:ӻ,ȂzыF
N뤒<ɉ Ala3UlT%Ն*ą6mqPIʩD
˴j'ͤV2,h0Us+ d\D ]5vץ<),<A=%pEP_: p}u>X9:"Ehtc6 t
r#\lAp/&xƘc#:ֆcu5?A Tcᕒ,&Ls9~l3-ETp}bN"/W`i.c#A'P}v`[L}Be+9У`q:^e[^t9Kyic%5]L.$UQGsY>Nk&lHjW^0ִ62- [vnm K Dzb$Y2+a|`\r ͟4}+g6 Fz)7K`^H\ ;lwuiW4a Yt"jƅsg;/-Co}J/O]vf4Nxaۍq"nPҬ(^2`ik%gSSx1\.>.XӌbSG3x{-렸M߮w|KR˷4(O aKJ9DTP(vɨ ˪ Q@ֵ{HҺKqhaR aV
إx8]
;Wٷ ؙ!}?3zW
1^DA-|Nۉ' I8X |/b*?%QBKć)l|6 2ǜK}DpDRl7NOHb07%qVh Y~YKY2736 H(]9{Q@WpLs5fkgf!@x60ޝ[5Ԓ2C-M
D f}y%ظ1=Ν /twWUA &4K_,Dghn}(!au:ahyLRfO = IC:oM<:i861%Oq}=pCt<&tBq[n-KX+Yu rhCN=
Kۇ~JNRq/h9HdڌJ0sBյL"G?Fܾ $j,7JUjWV 'QZ^Lx/R 6@ubbޞa*'
D.4s[J >#8eWp߇9δw? Spjja~g ewQwNv >X}y鮜O \3 d{.7x!X _1k6p(]6 X`y@ͻU,5|ΔT{ܳ+&&xшLeA L;~Em`yi 8 9V*%b+??bXC
B Q3*ͪ=^4-&ؼ&U=QtpnC ҴX/˕I.5 d[;R_.-}KhoU$F
rQEs\Cڃ"E˗/} $:xw&2YLf%'Xu1^
Rz-lZнP9U4pR!KmLn-Q
P/e`0Ŋҩ0ܵkrEFxUhpUBDž)Mmŕ0&8bF_
DK+8<9DbuyNy^vvyQ
E}R cЂUrf1ɃP۠zߐ@Îy"PTe^Ӊh )ߠ(?"0wWAjbw1Ļ32-"4{áyȕkhmRq#8YXuK [| C٠&/srzY>J.N B D-5<Gdb_46| gVvwʹo'~1 )+;I2)'{p+K\UkB 9 Eg2c?N'sΪe#0gUN*v]ɜ%s"T_RR ^"@J"8QY@FNޅ6tm1k[±
&KsXtRj~%]SY.d3gUOȨ#$kʋikR|}.vy觍&_ !71^RFc~Ƨ8|S ~&c=T.RJ/Պȥ0 7!jrW#3O =IXu%mQ hDWd]$?|^/
y\찥H7TD^G-kPEDQi\B7bKMOljTpp6k& ZTp牢ߤea
]lŨ w D>Cy#'2t:}k ^11l
v#j #T$hdTa(fu6h;?Z_w~#(ۍʡ* GRoxeﶷ# ZTɳX.~68,[qեp1 ׳ L79'WX:aT4p&2 M:j^fe]|!
'd-KXt~ JIpJ8[:ݪBFQ G@&'d<,v\K]:THh\w")]P:R/O3'YؙJT{V n|n?K~҈8[xIۍ=^dEnѰl,"p b ƬS,.|;ްU1N{몂.<4- l U9_B!W-g֘Ϧl=!(D>
OuOgyz%6D3GŊӲ\ÿY z8?kNq} S'hlĕ'ҨШ:\DZPHfP@p5J*5lC;;{++/ȁNuNh꩔M@$ {
Z♰!6EsޓX_)tZLRibgC$/gPCr QK9F OO%,'61фL߉n}tEHGA\&ws.dv2\rk݊Bp9~v k(r+CiݨR)La(vڴ4J`%%a TAkĉrYs))=xֲ8P1
T\C g颠i4$% DD5]W$<5[_:.xx\:.|vld2hnK>fgAւI >_Z FpX'g=?
^tIO
οsϭs|tZ q^%b5>oo5G_J Gg bp{%\ZB0/lP
tUhFkd be
-ψ
CZH\CæMb?(fYn* 6.?ܼp[#ͿwM}~kyl2)e& ~EC>ҿKK7a.;\p΅)9Ҁ͙Hra C;e* :PkfKg S~TiU:M>|' TcWѵc}I^/43&pD.H )~ R-Uͧqb
%۾<]VtUXnw~ ȍ12
0r䔭 2,Cr`; N8=7>$OJrvُPp[Ϋӯ|~[, `K JUp*!!4 E;4jQ6yԚLo2m L;ۗ7˕\e|ܬhfҡ W7ڤG]A"O
D# cU-CGK vh~D2E!(ElOϫ+>ssFｅS Q%!M 1@?z~GEp773ЯM|ǜ@5CJYiMa٨?=W`h-51aRG͎d*R 06l 3`:kX`HW vW-ftҶȖ
bj:q{JDG^G:k6-dg3ķވ]vSnƇtjQ!@αoAZ*;M ,Rn
*V1\$!fjoE"H:a"\S=z郒 uE.U)(".w:.]^!^OW[Rӻ&)ZS }x=-;ׁ^B$U`Q:s,Sk&h|Abh %TɡBJb7IVSR)&JV5|+f!ʞ*Þ.w_?~3 B[3wjr.i ni :LD68 \:n$xB,&.f`jes~g .hƞ$ Mb?&R# ab;s?ttiQD<ѽP?Ayqc`s~j>G/?7WVwZ2H'p,.^ndֿRVkk*y j:uj`Cʄyj:
jf蝿b.r7yW[NhaO <[[_`Qt5g5|n?ql@A b
&XZɐx)a?-;"Pa^̠2E
ϊA8\JoLNj圄FaFG784MD|b.C9%)] E\,]K:p8ʶb㔂T3]Ұob Bi*+;2?G!} !nն{wiom^P2yo㽙 ۦ]aw=eD.F37#?hM4Sp )'opIZ1.̦" vbW d]e m ß| n8x պe,Fz.0XG̎~Vwa {(!-m7<eoT x $1F@@瞐7#Ay9^^"l:r:VlUv:N-V7L4^F kϧ-&)1P=f_[X
3LVoh,$%l[%Rܦ:2spL`nd/ _vR^ҢaZ7o]i;ܺn?m,U1>ؐB`",/_QաKA+a ,xO Mj=CN3:DQ |Z`> `e| ݎQXJ1W'i?fXJRlKn0ɛ\nWO-J;Xo-b+bz<8q o A| WK.Ejt~]=3|9jpa: ζ{ Oͭu4L\23Ih[s_z{]_K3YIJ}ɭ4HlPЌ!\MU,ds3_Tbf[tؠQ74Ɓ2
;hithe*$5^\yPky_ʭQ8J0yKo 'a6Lyh
I t'(EQ̴ PG:QE܌ M
-VrKXrh'd8XX@LgwF)kQ 3:Y+7qr0nve5c]A嘎b|?+Y8䅄=]\n
moTmoBR+QHs8 WؿySjM7 j &PT8xγ{Za[9=3Q>k'Bp]V:?2W\KNֶw#}`*{(L? xQr>5P~szO_O8=RKrؕ"gJ@NW-yVXM}e-(\S2q?TȖ۽!Hӆ ~s!h* Ϋ]߄@Miɶ<;Ͽ6'}(W\wV t ?f˅ﱠ:aSz! ^G]c7,^QT|E'<`|i98J
;cdHAjz )V1$@ŮK i@1 #AУ2Z$kՑ ,XE,C`)DvRЄIe<_px`;VmPS A?5owh
LA҈w:LҜ_2 HH »0]:ǁdY`.'BA\_k/ܱ]iNWOC.+BV9 4Κ^L2E6-6!,idV*Цʼ :t߮Ha X@[@r [L|s_ *| ؘÚq[?pgV[ܠ6LxH% #RI>)PQX_fyK|P_pq6V/<}oO URFRbk.#DOPkcdy7 鴩02~2 'K^6$eo{1)
X~rJd\/BLL0XNg84f空E}CձܔAkl8mo4zᫍ67^owƏK aMc$O[tv[VGvrOlr,ĉX$fwֱE?oSssg훷7onݦ77o}9,.i_ړwvgIȧd{jmߊ.
t RtbUަwa HS'>Wdu5H_7Ųxnu)bgCsl}/ 8MQ 8ld۵($%m +DdXRn*H.
B36.P[ެ
ұ]*ZG`@'
.p \dL$n,y pBj\s]qgj$s8[7vc2}վ#8E~Q#=r
rcxÜ ^ec2ݎ TXțAG-= rхC!.D91c/LdYw slfq!K kRruLqdu9dkeP
:%9UiN?+5$]{vQ6l)Il 99]6nOM:)6Qp:J²$rdY~e{'n!unƢDO"9 ^_gR38l@ E6^ .4a*>"Dpy| 3|7*F$zERbHOG{۱̼߾Igj 1coݪ ؒ0 k&(M58jԺjoVh/j"5R'yџ~qp3}gͭӣ/S-\
+5AR*t(\eH0!m a
%;(@}4=]jٹy{2?"%]/>n?>b,=t Ӵ(cCەE Wۭ; >G'lzW_Nt
't6c& Ǔ1k^[, ܈[U[z6ֳ^G|ܺs'* A[;w[Ƿۭm\堎O[f7 0@T&nT ;@$vDi N\K9E3 "}j
Qtն?ZvxdRjRv$^v*XN n-H.RU<+L4Ll /bBt6oZ OC`,ǃd_d(N+s\oݾyg< Ln+^lRQYzJB G R(H(+cv
1;@oΞlaz+ ܽ
AV,aDaX^*QVp[/iaʡMn}dy 7J{qsE˩sT JG0MPCAT4 _Ogctn#C()uNFi{ h~33tWש{F+ 'Ė>JԇaN nP,[Y&&!rOOYPOxT{ ŖYt d+dJh3wO3 'N|r);Nt͒FKv ݥM rd3^/։i ԑGN`B3+nTbtGpJlȨ(),2VC>\59l oy=ǹq p W*I4Ce"f V[1VG4 #=aWLY
#-)Wi#<'-1N ~Jclz3>Hm<,
.?2Qy^#1/h (f6M5c
&6uY,"5W#Wf6\V*5ufN9yL ౬ .DK˙| m ʚ%@ϩ DU *bqsa Y?
ig10+4\ |@;==z=X
aQ@1 NHqN$x(uhv#@61;Ǚ33 IwXĶjSD]AK 3iA\k‿YI+Fzk蜲6,
ti<{@c;Ԃww5F4k/;RᖎKnUo}oDjP(^ʼu:{NEj1iտ#3t sAav`eJ}EPe
(O1NI>iƓ]o`7[_x+ f]7vȼV&! '쎠 One> JvCz[%]ˊ
)S Z1ܒq+=eoy`OmJoU~W,)M]lR
x@K bh`*xbTT$+&"k:Ql[
J4zҽz4,־n
H7hٹ/EuL }+wAACԳ5ug&o] ߜq @,`+'ܨ06}E ɀ4LT4MZ xigW~Vq%Y"OR \u҅ ({ xm>7w[Fߪ咭>e6Y$ ob9śhOPs35@x 9̙A E6ϝqJr;
,=Z q.NLh duZkݻAC)߶?:0+@JmɅu2bE1_*@iVQo&A˩H:lۉcv
>- z]Uv3Xl7' r`|"76 3de
.P%^%îư ^TlcPW?_'K[V
0X
ئ pDyM1jXڷ;C ďs.~Vs K4/
t@
-xd.d D!i1 Ft- f#!~N_ʏi ҅!.4`Oy"Ny+:=<{ebvU*dQеeחa:/]h9̂9[RyX껥W3 !HגAJ[Y{xo+J.~|]8 ѥ1efjݾuk$2މh/ Q"BBSÎ4Il [:2~sk# ]-\I!1.-Dd T 5 ,ǵVMp%r`pEP+i`bQ7A$
gV9:_`|"@y|3Z& _TK
lGKΥxK
q>/>/IWkLVܺ"ҝh N' 0Kf&C-siZ<Հc: Gуe5r'R4_~w1}d^
i,L #K
Pz"
T46awB./_v%:&(K#c*WQ܌߿lʿ?7 ϻyM&ٻ]/mߺ{'qs
fpq{\f?}4 O\ujBհ24B E~< iZ-ې/D < ΪB8Gd9X@T5>[ ]PgXO蔃1Ēﴢwֵ :q OoXkSnEA=Q(W8S}\STE`@Drkort7ѵ Y?H|N7~ƙtuũް"A` qo!&|X-*0/R*lޱw%krM;(Dؔ$a&j&:13dcbܗ[aaI|$s<?t sܦY#.66дgka/˂eaI#pޘ_ dX3Hcy/w&m>zcn@ X|:D B4{渐
b6M Pr*Clq Gjv x~`x㫌}|лW}tm ZDk Z]k JGiЃ][SYA % ~dy@OOX xW Bw_ z+|t,%qpւ\f\0!\p= Sn}Z' n8
6WڅWi:a@m ({/ Q CPUj:fY3 tK{Dʕw٤N O
{= p%yX$ER>^>FQn`cϩJxj53=\oZO\q9{
b.`A PHଉUBC%l*Kz%;%m@.en
u,ƌFqzY4ϢoY.JI qVndK01Z":~7"E53`~N hX?zز0 }F 4?G>mxwm$ <[D$qP"#&F0[cz6T_n,5QGG~c.Ł[DFg<:qpm}2@rgtzO"*7xbM烢 2{Z@aKפ.&yftK[]a~ZwAieI|o6'$%1A ]+
GR ӝ
oof.1dֵo`1A) FQ 3v +kwi5!W
u~`%g#Np .&4 7 /8Ʈ; ܍.(&cd} ,?~xAo wumYX\m2Yvf-PJ׳Zũ( +5| +|bOf(U96^_z`YV8J!R[UMZ0?>8F0+[d{ݏVp c@ד) Uaӂ疴}R<4ea nNZU+Xn:zS^& ziYs"?Ea)8i }9kϓ)މđ&bԴίiͳtF8ku4d]ՅI! F6ZZVڗI K Zёh:c}-8 L*7O}`ZkA UKuהNqt|er u:NHL`4WJӌȳ
(_.-C w = wW]0KdznEm}YŸ§(` 0 taUFRBD[yr,h-WьW7ᢎ~ծQگ>y})1kܲb9
JTdA(5 4Ki^p7 PK{#GN1>7oYN5K||Ht0T|rjr֒FQۀgśZB {V 9[8f f|d,j>fEwAG6MnK ꀒ%=]aZKX^û$6`_Ae'Ҙi>f HM.qr˯w,.H8xqU~B+VPQQm&14V/aޔao|b5I:yq_`>Q|3_ȐGkh<
&nr)pS^'ِ{~DW*ܽ I
yF('zf]v-3vtf.7lUQMx*u\ڹ]lYi:~%nZ{+>[Z\Q:z?{rM3~"xAtZ+`Dzd?GGQSWiu R>?x֚ gnh 8jdߌLVDm \mY-O_gr6 r1AB1^C d!p &]Vz#YF&-2jVЀD+ E_L% M8Ɓfq+g <
c-Osrr7I!| cG: WץU.E4Y9X"wu9;8JB
L:͉
$xa 6Ş1_pmiL0:S =x)dknEIJ O+tؠEŃX,11iM lm/Ǜ.ߣ9v ~ާ@ke_g4 /,;nx^RcB0ދL{V `Gh9{/ =;d-rL^9XO3b, 8;~0[˭/llJ~YΰCwXootۺys֭??Olu%ޏL ҩ2t<`~[ދo/_s$??ߏLYχW
.;KO3Ҹ9 =nia iP]lE{DB[ ΧVB{
ۊط$ !zsO&oY p2awQߠ-ʃNƗMi7>? < <p[b3Y$ a:;5*-z"NRs/(Yȝ7,>chDbw^/kS̺$ %4mܢohEg m=U$38+U {. k?MqYώ/nܼu!աFF64C}pJZ
}Sߍ}qE>};8>{Lnߺ%?ӓ]?;<)gns=|,`
#͈@{l /p#4h㠙OkNzܰt8F d9?3H-Pm-x7!*MN}(Hm6f.X3&gǟGb{D:ֿX~c(ʈ-y'e|NMQV\. .- 710s* ,zGnAit|RJoĿBVϾ"QڍCW\{ѳ>p >?u)# PsRw?ۍ6/[H%WuUJD
RSOQ |7xZ>7wn~sC] fAr0 @ih|Z\|pG `A]{ `v4?B 3ʯb4FqܚB5QkYaZ8, 8]45z.<`߅ai_ WU#&^b"g$`'RGy1et:pQ6MQ VPC/2 &*4ҍE)K+ щal: gVI-ul94G H#JR;9h}+W-<TM>\MY sa"]Kq PbPEm%֎+ E,9~nC-SowOh|^17dBPnmɋQv-,W=P M፶5MM9,Am]gG/>'@ώ6_'KJgQ2?' ~߫_b WyoRڿ}:\ ' k*1}F_ M~u6]|GE?U: |wpO;T߿_ϟ?=77;A?Yj1O7kO}MOFߤ[Tǒo[|~']?{m_|E_}G ϩͿxB/>k8r T>u>Jhɿo?k џ S( @O>m?9/c$>#7ܨݧ N?W>}7>|w>{09lx n pH@@ A09 朣$R,+Ve9ɒ(9J4(۲,m[/1w )7)LOwuuUuuuuO/tirmޒ[{->+ UhZȇ2
ڀ2CG>hd agQ>I<Z߱=mw!ro@n-o <X
m~ yވA-wW K? ez]roD=|dz_9͡vӹeХ;Wy}Q_rˀOi Բy܁A? |_ςVmXf@wfXZ^]77F]o8v4x+ x|S x,Kȫ2$ 5*?Py RZ,0|˲Q5Z3ׇ^t>Ul]>;}~[Ѝfm}W , p
@iSz" RkU=cvdl Uu\I=k%^$e
+k> ; >V@{%vY~g#Ӱ@Oʽ676qWhӐs
>0z͂.9 c?bwkן8д ^#?>O^ XsG笎XZ/l< ޫ
Tiojr/ۿ> \%L߫˛pQb]An\Oл.RAU{:v y5;qݚm1@ )99 H` =iqQQ۬/5!=7l+J?>i?Ulx7ν 9m0@?;u` `*l8 \ ٖ D+;
jFL gY,]=Ng ̲zJ8V(éW:8uuwjXg]ЃG0|+ǹ3@w .B> Gr %M W5 ȳtO
q?d>zl1Row1v>p}0?oaz2B=t-f6U gk
3>df"AJRnkpíK. OvgjBBE&{'ﯳIվxڮX /|2w!Mu\\ u!u9>tNu02,f&&s $2p|`|biLWّ{Ƌ/ΖU;vJR [Ќt NY<Mkf<0s x˼|\TS6FJN@9an&L]!VRtNFhѼ# #
ww,݃VrBvG 1Iw @ yUh-@lٜ`][g[k")UOL'f@] xMFײ-sE:|`yḪ&ϓ}H}i<ýTK}Rn,]hk6kuN{6x8=h //38̀\J,?Ā϶w a{~7AAh#
PéqFd˧Wt{?0Vpç _hl? `^heamlFuӖ+:,u-,s|m/s2T>+־Fxg_jJ&K 8;ڪ8/~:kg&FY3$KQ
>q wi>HD݀5]ՀVQ zx
X+jMyT
/NgJ/YVVQ zO%҇ 1@]>oQb?*4?8rm w9au'@p: 8yi=R) |,Lc ɽsĹ:\I N_)4ޙ?yIyF;}G1w{R^Kj}G,yb ݳCYC;[at˴6{%yśr=IkH88?9+ eկ4 eS S#9j[ƕHk:xbS}I.O{i+>fkK:}{2p7֫-/&ZL3?{z J>t9\$ /iL L)z?7teQחTdz|T{yɦQ*fI˶g\7i;lP[O3B?vzkK sd}w)yqSO9F-!iNxLZ_|3hgVW|=R;Iia>Z .?36J/$O9ߞԙj\O/ c 70O՚gZO?}o wZ]}8~rkw.#Z<8i<}ԇҥRˇRRmI ub҂%4ʹ6iIZ'e,[:=~hcV~A<^mRKKvXbl[fӦd2
>:8giWG]9 ʒ^I}K?', =3famIG-IK}z|zǬ:+܇夾z>j7j[=gŽčkTWou4 GS={[E,8S};{& Gk){*ܿgHiKg?/~iIݾz|Yvŋ6MKC8϶y\,qkXҶ/H %Y} $?!K}'XdB ͊ Y+_V'=K'w`F i]Uo~EVAuRZ' ੍}8R$/?tusRL:9"tnVڹF:>v[87oڹ4=+O_ R~d@ʯzOol^=Z6{pܯA"6+gk־J`dIL<
; lu݃g-}9|_Zi_ϻto'/_lЙ6Е eҵq_f{0_Ku*5Q"y5ls_FyҹPoqS;}g>T'ө ͢'jjCN0.MkK{M9 ׃4_~O4 CM}ߚX[/{cz{q ԓ?úY4z?(o|VnSڗ5Ks
i;0-bzhlD z1Fܬ4F q33ri4[}W'a`:I95?G)-?:Y31 5V~T2Mߞr d<$ K^M`{S;J}̺(q8E(-;y ! z
#NO0RHz3[?ʤz˒aVJIGKRvp x<-^XJZi~ݼ{_4wM;(ԹcC>Im# ݒ>>LjaHz֑]*I=ɓ!~eі㊮L:xZ/eI/ĕwi^ |ǘ97 T^ޯmZOE*K Ti#ޯ3f 6+rFa1# ]햟w 'o | Vi= "k_Mj K^iߵy]&u?UJSV|)kmKJ}#vIo; '^z4q3͛U |/,ʹ2t>b1Z7H˂i=i\ -_cWi%(W:R Fud%|tn\ЇNH5 Hyý͇N6Aj|>~]]?_ͧS&ilǟ
NxFgAj?AƋV K9 )ݣ9}6Wǀ^dƨ,Q\n0A_:'_x00s^Ԧ\uc c3>FJ=>V:xC+$|p3<wK n9oǷ/ey_ᕌgSm]<֏=iZ*CFEuurl byRLE~~oc~=^7F\]O_Zy_t _q9X_Q/{g~ Z::eΓUulT)p-C[< : y[\w@nǿS9YR )6֙-)~}?iQ,5668mc:6W.9 k k~«1d t#!_'szeSXj@y/
oă Ւ/Bp
}ShwL' U}?˦?= \~%cs99k1V}4M /oϳ c>>}4;+-gq ku8x_zo :{;ٟU\9Ws -"FMޯl>##s|?Yߋ{]KK)S_5灃M6 $$3Tܒ1 MZ`]9 g;zM| p~l/[2K<ݟ//
r4oz3mve<ۚƺ r .pxϘ籏ɒ%k#õX 1%>@Uj^F㹔7CZ NJҼul-Gj HP_ >:g m@ɵ|eV=}D|&~ m +iNsmcוmSW l5Rj giSIzƬ776JשN6OV\=<>?u1o|KG}ЏqaTߴ%y}lxԎ ~L(q\S+'n+{ۻw{?KXoqdG4 W 6wk7r JI|RcTo!ؿnıiooLHtd`R+4Խ /,Yf^eC{Pޮ4zٞQ_%9MU$_Qb bFЖ.3p:Ki߰w)oxmvQUju&fo^8ɠ^G
(d_Jp Yk=]mj{gߢg`F^/,5O=9C?ԓ ˪Qy=//Рn/:x&t gz6% YYGV
>L~y])MÛcV|byےiL9S= rWݏ '}mѧZ37I.DߨS%y}MjUgkRyW
q-!bݤϯxm1tO_{KzȻ 'tJ[zw[ڟ].&' o/N_o|~%R _k!-.=h7]y>o}\~(]/_'~? v_1ezj%gjI9`ɗp% uOzhLzclGIoFQԁ,;3 =4KR4{!| ^~4ΨyHq^]m(g=NyxQu~ `_(|i/ at$8 {.HbF)x;ڑyԌ=
? ÿzMu3-Wc"YR}ķwAGR KI ^~ҾPO| ҊR#)Lcz PE}#ϏឿFr|<=Mj:Ljr?+
=}#v-i[=o$ϝR^=IHs87|ߟwi~n;= :S/FzZXAb ׯW/r-&y_9^/__>s2l47Mq&eS|=ʤkMYom3N, e'xEjb_|?/>8~?b/#/ _w}ٖ T&~kO^OwJ}謾,=JdPp8 d?g)$8UYmꓞS4s!zw>VHx͚#1BR>В<ӕIzR\YSy%z|wn,]˪#KYʸMjyx'/TIdv9tdOeǴYiiF8lP=Ѩ|F)9#SWpQ^S ҥ3e'ˮzoԟ;/R + {u-#4um˒OK_Y}&m1#Oo4FG_YGehJW#{RO ~ڛ-jo_X#(fm?vE_p!uWzpdzNKOcHk}(3ʗts/(q/mI ϯ1hCzO )N_߃&rHg }EmKi}՛('8ۓk<(-yg};)rw?ݧe}7&*-)eiOٗQ}~Pيir>#Z~ۧ=Sywcγ3<
Ӵ婿=4^N}D&W߆ |jNv6%zIkKeSS ~|UϔOS]~'Vpے6kJi 69??Mf7,doOy5d{,${_1?oLKeʟ|BҒ4_zNې\Vzʋ9m[V;NyQomIېkԶ#5C) eLjfԓZV?x
x_vmNy IF۞>?oKDY<^,$ϩ-W}FnK:e՞o>,=Nyj[of#xW ,KɀW>ţ ϣz&)}Zw}Em;-tJr|R_^_jc RZoK~_. N p&?~ߔ\V
T/.-I)%9]iY:-.- S<~_s=%,;ͮNR>ژ,^N}5ɗʷ%]Z} 를}̪+ϩ?w|
B)E꣤6#TWJͿTz-t ^Z%ưX砤 E5jcpRW9`l2M9re~,H#ݥ3#My).M߿50 듊eKz,}eoӯAcO(|{n+ N{C跉0~C翅a ԟc3KI~ QNZ܄G{6iڗ<5|w W˒aV]Yu˛9zudM8 㵅,I}ZS> jS4j{*$o5?Uu2UndzcЉH7(% ,ɺ/}!k_]Of'CGoODfjSGo=q* ٌFx}VOi{Zlj7:(ɥz/^xBGf5^Ǔ}"ɶdldV>DƉB,zuzg ͩךc+Mq>_+.Hm̫5#{&^ ;& E/]SkWբґ([NQoC[M}MjKz9/&y< imluo"m,$}]V)v/o[5 <,&]'Ju3٨ %I(աr~_ۯ{}`Z#ymT/RMz zg<(}>^WҺ=~ZL}Bi˒+O\g#O(hy.+nI9 u'knSWz?q> ưFutjszګtY և<'WwSC닿=tp5w-} e =R3#+!)tBդd
o_Ke;FaӳO'}z[|x78)HS95j۠e{ӱh_}7Mz{_eZ}v_IEmЌw \m1o./Ja՟AVLEBc>cU:Z8XZ?Ɵ}Eå־Lr>Hj%;3&iHo)vJuqS>i?r{e]9(|+J~+#ݷδ$OWWiZ_<,Ȣa@·(O_ʧdܧrK}Y))џU_zR_=xxU]N'HRڍnc/3HoOX3(L
izѕP'u.?ߪQYB_ǙR{n $Y 1kЕ7 =̟Kpy|FzKʱXJKouu6Q?v5 :Ϧ.w
0KOֲݽ{*
R ls 3L|^WNsnv9̺ygi??Oӹ~t^^uka~7=P'O_c:{eNztH֤L;F4m 6*TKm{>ޚ+HYsjvO{"Dc|m+ޚ?\Z6Ɩ>[ n~Jc^(4 ).뉔r|rr R^R>ב,ǧt^W(&]Зt
lV Go˱ y^lc_u)OaX=wr~XG{fAνkPFPw?*S)9[ :yeRƻzK9xFu֣^B/e7*߈z' qҽ%'7zu Zk=9ueo$|ZΧ$yOJ-ӺӺ"m$OV߭|A/l~F߳ uxuz )>0w_r8YJ !?2O?c;O^aٶG[ƵNz_U )^? Ҿ_$]ڒt_k ޗr|kPyWit K-ͬ;ː_rutԩtu8; WGRϓF6*3;+tz~y<iʇxy{V^=T{>x]ؗi$,ö.,|ޕMu'/f.g h<
eӾuÏ^'Iu̗}9){{Ҿ2:r/Nzvz-d ^., ur6 k]My9ޖ\inz;O#HǁbR.u=oGFԮǏ%wu~h +Ieіԙ{ޯO%
_cM>}T߳o 5O_d֝J%tLmiH}Nvŏ
E9 zٰM
uӏM {1/O.Jm2WʤMjr xu.gRP.mrXK:8^#q1K#|~Bo ʜu1ݏcisOok*Kx=qۨ|?m10CRڠn/#egr ra,LZ/X[\>~z{L\^wXgꋷ~'(rҹ$31?X4G GsOb
{~<
6JtgEiZ9\_Jg=>,ɪׯ;xޜL}jMe"/~gzs3YFiڠueљ$+_o| ٴdњE {R^WLfi}yM:KR_ϹfȘ4E|];;oz8V4sz/;{cOSژ_#=REK>9?Q>ckxזQ.F1{2y_]^NbR&b/iWqҧqnEs#y5҉bFFzzzҔzE{= zRhPd-^{O>jOzyR}j14 u~qc!P?ۥV.oKK~Q)o[$7 fΫ*.*K!]f
ꭣ q{S}׆1i ^(_p̓[JRFud͢/U{|hzt=^U_Fzі'/d:+\*! ; p,1\￦t͕5bFE]J>[\apF3!<{iҽ5 m)ҲM%ϧq69eQ\+nMh)r^z7$ Wo.:?=.I/|mR{Nnu2~-7R?υXOkR&ş%gfdc>7Y?7Kp76x%zÓu,z_
hD{5miɳF2~%e_-<'r>y}Ͽ*7ןW> sJiIqhP[
uYY{^) S2_}R
^3{>EgN'zԜy:}=K}t @>WC1K
=uۧXHIV=opNI\ZMwOokgKwaU|#67߄I+Rmsbty Ưy1W;~Wz1e6 w.ϗUo>Q-n'iotcDx5֑^
Ȳ9/- A,YFstnfzxPksd775{? o_hh<8|6
eۉЙɴD{\8+ӈԟfFʿt
DUҝ/WD^*+LOJwsS ݿ9FT'O=N1oeɢ7/~ǧ? wVެiY)$˧8{wλzlDK_toQ76wSƬSJyN{?ѺG:_6kTM,g#&owf#rM,i JǼ<߷gƏ n?01fk>&2p
xݑM y{ǦOeN{Yoz6c$g˟f}^59_/'ό W_BUu}/7u[/H:G:|yʯv?ku[FH%:|/ǺJIYϛVKeN ݞ'R{AYjm ʳԝԷos}Ujs=B Okǯk{dɕu3\ -y/A܌oBJ{Ƃ\O\ њՄl;A'/PFkDҗJIzIK~ u}' :~l\{~@r<-3OizjwҴ:pfz8I iF߯G x~ʠQMy7єsRft~ߥYN{AI>R!yN>M+קy0k$~Vx~{1^ .DZyC!lQys:JDž L^D ƍ2~s}R/x
jB#_iW7' 5*W> 6>ߦ,ҷzjCoȱp/K}׳ 4d &~_N'鳪KmHcMiLv̧nw&e} GigΟKu;~{,Ck>@Qcl>^68e{ico"=~gAy I-Cڼ~xǛX
!)c}ԏTK~H&O:2<[]yʝv WV(:(nR_qsS6㩦{lx]k4'JYӨ i Ҽ6Q)}5|^Iۘz>ő5ExZ\zs|_2p t qo}jOgG b i@_s~]or+&|0z{%[nY2|%gO>SLScBj8SђQ.?ܸ"g*qAʀ(in3tSx=~E_-]lsxFmI9ZϟwV&Ť 틗/&ķ9]ml>':ۮN{{] ｾx^ ޯ ~>ͧ%[ y^ bJ7i Kp8^8'S|kЗɻQ%~mzwG6~N |yǘ 9rk'
: ^~ h9
&t # #3` `4lZ800
p!`3% { K[if.]{;xu:yVnyJK}wuѢy.0*RR˷pz~aW[ ʴ
JPWhby~ p鵿9Қ\vލV&],S{ŕw隷`dF/h19R_y߃2" 9 0ϚvRj?JjV2^z :F]lz?N_$m}F?KHX}ђz?Z]/W+ѶڑxF=Qi4W8qթd>_i33|l WfsԎWV5-bKhow6 (,BoPS;x \KcxYynı:q8/3ڞا=ڣզ]ayfI tiZm s,mr>WA~t2\i2}gݿh^f_cx\;Ǭڎ^src2*E _p/
émvf?]["Ѿx;;ҖX[h.8̒h[:QgS\o8H,qDvDqͰݻk$쏔">5خo<%uS^&Q7-,?}fvQwz}w,fjX8^i,2|99\'ϾNb_Q %+$
>mEVqs-v]eW!|i$΅ؿ/ڵGbA <ۛ;>6o|uՒ1]9?& !KחZ* 7ͥx csN7vhG:c>>; |AN;z/.Hm6OyVK:FY;u9l8Ƙ֚5W(j[/6i_Tmھ-Ow{>4S-M {h* 7ݏYikMWI~dA{]o/7]I99j4_my/6]ly/r 9.טjiv?pr϶2Y}>s k jﶫ_oP[}K3T
V sw]EMؖ{% 4Π[ Z:{bf˷Z]o,}ҭN{^aXgԺ`Wŵ@ѥ6Vs^\VNS|`hc`ѻڸVv8cCKJy?XnmTe7Ҿm_%1Fb! {*f\qO˴ZG5:$~x}#Ֆ*+Oڕ΅F.kZrSy;-fK>`髌S_oZ9Cm:c}+-:玻,Vá wk 孆KfYcq4oѾxH}}htCc:3-mľ>p+WJm}թVvXz}lR:ױsZsq3]k97f~p{^h\hmb`ĸë<ֱkRcq7¸=~_`mY-q[/q1ŖĕƵsD[8N^ca+ #OI ?hh`DפOhұEiys˱hĹ|cjs͇zJ>.29$q5&/}ps|c+$5%YZWY}M6Rj> 5rhz+Ng7ۻm+Zz5?69YϷ2\c K{U6 ׯKsǾKO?%m$.fO3~ˌڦ F:3._0XjɊYײ&C_/_)sA}]ym 9t^8y.gϹ p|kMvi[KiS
w8 q=˟0?
^+1&QX[k|_>˳׀>~ޭ0/ bqҹ'-Ջц=o曬) Nϲ4AZuHvկcƄu,1X$m`KVWY>G7ky'j6Ose6sIhVJ+VZ.
)J&ߢ`ڱXt[`u%tJmO%w,ֆ;-xK1i%ڊc-J+zsA,4҇.qra*MFS}Вq)-טػzK t?UFB;3hmT,?}n9xϹC$ =$r-YyΥUudD_k g丮ewD?>{FMI`ܹSbiyJ{_#qhjo0or-Oۤ}uxuCVzkyTqB:x1qYg*J7粫Mk$֛ cb-2˯,X%F.s&Am3:h.eڍFO!^;
/c n+luq_jt;$z2Rfom[lÕe|Ę3|Ę&W4uJ/iҾ2?}iX- &%ti$~]v ?ĵskS<: q-%Λo 3(פy`8($~1A9<&>W iޝ!qM<~'k ~di. cM}MKýWFH81hS>^Զ~˹q][=wgu3RAO+= qr m87}Pni DҶٳfizr ~^#{VTZ5=:|=J).ow;ܻ)2 g_uw=D:[&};^Gs[$8${賫,4pf4 RݻյYJ&sObF{UYk;c?L~QHW~=(8fq dxjhf
%*qnNWr>ɞi4MOK5YٲDsl E{M.ϐw)c}?hNkWʗW>E2 7>m Sh; qv
6e<e>/bUoJsD߿ppՀu3:X,C1cVvs:V0W>kír,% +%i!%ڗ= {⚡_/W [p,~ӭGۨzO{GZJ7k5)6_8 socI7v8dfx;Mb Y9^u9 6'#˪~L3Tx;'O:FJw9ڼKܗ=S-q_r=N7gIsO=h\f|[$q́JK\:8:Ub\{bKm:.;7I9[y&־.gĵS%\#fuĽs]&Ն}v`D{$f[Y1COT⚹Ҥ~$3/w%8^ok rso=??G:>.m06385,PB>j<*KR}~-^kbfY iGҼﱼ Fd>$Au
/ߑp?5u{˸Zarޙ6'6Kqe:^(_/q:Ҩ6kԞ+13huϱ3\|^=upoKc\ٟ!p_d<ޫ <o H.ZsvĹVgl2 \t:RA|_2:.!q$ȹҭḗ+'Ѯ06{Z>)U}|\' v
$'Uq Ϋ[>˕p#71kP/w ǻ
5 %}b4_'%{$2[E_wVu/mc=Ty{G~Bּ3$E~=yGR)}STS;yĽ[ #x-}%">+s S=o7
=DV~PKF*{GyѴ`D[4<>~z#~ k{nx.\&q]{h?F]#Yߥ[s,ğu2>-qΤ\ӥ y){w5M\W گo1+>3n#4- *1~0po|D+ R{:Xs{,!˳۞Um>=yewI=ߵѿ=v)N)c\3 oĵCЖY3%+~Gb\\C*ISſҹٞ
5& m-wHyڎ-smBG"G߇k %~0&rLr dI:XkS<'JܫõCmڼ$͚*+3U>6{S|c [)༆ABɉ9u; Bmmy-~OCF7[TuV5Qï+qGjS~M},ȽW;%>ڗϸPm{ R Wmw/y+:r2~w+}_/sV'}Jq=uN )qV'IS 3%s$]Ƶ[~KoT: k啯C}*v M
~\+w;ҭ{|?s$}QVZ~ɋ./Gij9 3e 1=)- iq~9
+_Kv+YL>7h\wGVV<14Y ,]"{YK [-/u8O'q}d ٽl96C<_<ߞ{Jz>i_}8 S'qmhwo} $ }nj
2Y?d*J x~e=?קVK`,Y%εa
S'F:>"{y< {GEּ3@ xy_%Q2&D ?QU}z)a >P+ 8Լ;ϫO[OHsWIfu 9&4{ūz=x[%}
Bj c3Xoeu}rv^*q*i[y9/~#C NZ^Zaat=sQp/ xs
6ϷK<\y5vߓk:#qMrD?yJE"qW &[zs}= *qOQ8#xqPGK\Iq9ܵˆk*1|#kpO Ϣ]lUIFb3$OT]S;˳Wx@^bjx6`ﲲ<VB:,Tsi1~ïu^( %yʗJ<'aD{,ݷ}ѩe{)x^ gBd?_٩L`1[M{}ތ2f~HII[|rkeX +oҟ! vd8p23>z]7YoΖ/F+ -J<X~S_\g<Ӄ6i /xi4AeϨh8LzyN9u,@|7_om]omY#ܿ}GA[;G9ˌK/z}D!bg"vPp{\;3 _X=~ɏK^e}zso6><(qLx
}$-;x $ 1HЮ^its͑|hy?vE+J
k%$߾yխZk$ }~䵆߁w{hOJxr~~&㻛>!.}h:Nq8/ǹ;ץ.E/\yF?[m2k3p6W\/lI5x}{ M >.WH[ 7mk$꒖PbX>aӯy۽S%~ϻ[oYuZ}h=s@mjt $;qcܧ3|{ƇijH7}'-jF4-q~ɘ[^9ʇ'%d[Yjy%>|N]oռ]ňK|i4vQuK7)$N]wI-q(gg^WkߓVfSy3Klu1ַd8ZYΕwWGV u8ڌk$he
ne{V`\3y^;1ʍ(|XjqLQ̸1mnmusnWXu
Q9 %~u13%3 si:
/
X_#q- `䷸&=c
c\]F>{?\o{s`շH<{iD?Z|
!Xr=d|z>g^x6˫>#%]]h C%ٱhd8߰N%5txFǩ,qj5_k]mեFBm-X8íwJixn R{y"$qWH)+Ͻ;%ϙZbrn߁LuoΔ[Gx m[ |9I+m-;)NOǐc:ɽRͳ/c 'GaaG#- mO%VHWI{E!3ڇ_"=s, 1 7ԥvW?=,Gq #5F]cYƿ }&?ܕ.p"qv5?c\yvk>̯'dAtE aVy\$X"R;0:~%~ƶOޒÕwҜV/wALlKtu0lA˯1}ve鯨 FTuGmfFH<7?/_v8{;+>sB٪-WMLL8sRbls.wH?Xf{.>-V;%(7rɖ;h|,=zGؐ7 !]\GS,G=t]7I2Ō٫.V~G>7r=,1V|5:kҷKvgX!sEKo.@7Z~u3^ ?#{r;%-7K<;n.Kb1~v1, 3Z9v/hJVfoʖ96%R77egK\_oesKabBčV7FoNOh]꯳O:>G?j=Z >kg =n%i Y*/qh]~vaõգmV:L(NpԾ}a]%Ε
.џj:nކI Ui<(xa yz R|Z ,ُ?\X&{H= !&?kƃ~햟kAg0+ov{~˵й7:$ s!QO]'o5+~-cun=2fSj QO;9q} ޱUwԊuD}ߗ
چǵ:ޜ!Tsk{ .x^;ΤHj\3ޞjܯ=Am*q_vʊyK ~?~=)L5}IncZvj[>&?粓v{kdwy +Hm:`ztijmwZ7k8 q
NK&,W?R~\[m R{&η2FCs-VXWsDc>~9 qLmЫΕp4$~CrO }Es& {1kF\{nwt]~m{!tk Ζ mg[\{-5|}ƇJ;zmD"[ z Q<[aĽ],1b{!)C _8Z @Nys<_sw}inlx_OM|Ws6C5NLnqqk_[R1 ~CUGZ=R_l#o۬}̯}lDG?./f
/|܂~a_NzO诨 f:}%.:Ʌhs>E#^6s~D:"Xw#qiKgZ_f=U wR;Ljv ^ڳ|:Xq KIT5urhyfW5^@W`K쓌x 1l; 2>1D|DeTq|a F{fF9E}Ԯs_:~3?'Q_J"w/|&ʹSoqq- c8
yvK<O 1:\Eır{?[.eE:[ǃ79I)j}+CF?28eiZ{gk 9w
gkڰ4+ϘYdcܧֽRƤUF89pN v=G~=hWZK]/~_T4x=>>.w-fJ<'8clKw"J<0LjDvډ rD _xV^>V=81K-q'BO :Bj~ۤ碾lJԷ]$g! SR\du-Iu|xzZR]δ{\{NG>Ƚ^k=3w1ym72?=z"1^W^+5y~/J-ˀҭ.qxq&a㑖Sjnvo4 JmZ.oS ^}8KʯG~
ʕ*
/nxL4^m罆{s XkjjcHOLX18nZN ǖ%}Xf<^g:>d4)-
+dz7ok~;$I1$o<ֵOI$c5 #%UεhtMZ[%o~b |]P6j{Z%]{=uWy뼌wmsMS>_{ɟ;ʓ[9f,91( .3<Ԟ;ji:$/o^+k t wt=&6]vgÆnv{Z}6`6H<3 앸VW {}&hߊqݧ93 &Y7X7
4L,xuMYH*<$ [w:.txo3qB}Y} K+Uc!^{Ϫuإ-
罆gb\Wo璴)>o`>|iwJn#6v۬lC}Ɨ}̓@J?˸AӸ1&GiH<{lxn+הZ[UgTO_*/qm{}W4-Ẍ%sroGjfkCߎH}YbWs~gy;F.^o48jo6^< ]&Or D^wI\7[amRiTJ\)K)vI=*:=((U־xYHdkK`Ͷo^Ӹș.\| z< /s_,ϔ<|go]u%ϻy%Ep (a HIY+2PsXa pMc/}̓3W-{GÕa}}u*?~3,q}3zԞ
; >Vj{x=y=s_E\+q/ cB>i m63TI9>qWq1͟1x%ntm!W79i \?LM(] }+oqhnC4M`Z'0n tC$ o0>56ߋ)qN3Z-|rՠd2漜kOϹ6Ef:u5Z]߷~g+[ty|\mqW=~~XAl=^kV9>Fu-3%~̶pO
}$Շ M>~oAשt/[][{dçt= kL& Qy|J
rJ>`⮚(SL6j$yk/jp^t8{SFZ݊CǷ6{:N8܈h%> 8 sYC
߁2sȮܛIF$i$_m&# x#%/ _{Ęv}Vniw|+qV2rI gEnڵwm=[%.B=> 14w8Y*
;nw-J1u,. wKgpkOIC(As "ql +/ 2Yr/I 15)Iö q1M<ĸ#U6ߋ}ʻm(u,Ͻ >˥ブ=C]>~1Fǔxv=@u uTNF4 uRocYWEh|\ޚVvU (r `}I]hgJcJ8W][ ݴӝ)qDzw5 }x/E߆<蛒].k[ oLyHjm{I[v.3~sM_Sjz5 sbo+G ʯ*f>X3sJh( UoBbOڳ>b8hC8g̅8.:ʴON|\4Ž4Hm_ӱ ?$=%}|k:M:iy9=~/?V?GO"f:sk
gYsc5Zf9Ow:<8>s iܟ6ixSɞϰq,gZ|VCjΗםd8Kbo ʒ1.G5q:vpMlO1s w
>6Pp2O
>3C[p3IZ>^)18O,9|$7
const u8 BOM_ENCODE_UTF32_BE[4] = { 0x00, 0x00, 0xFE, 0xFF };
const u8 BOM_ENCODE_UTF32_LE[4] = { 0xFF, 0xFE, 0x00, 0x00 };
//! The size in bytes of the Unicode byte marks for file operations.
const u8 BOM_ENCODE_UTF8_LEN = 3;
const u8 BOM_ENCODE_UTF16_LEN = 2;
const u8 BOM_ENCODE_UTF32_LEN = 4;
//! Unicode encoding type.
enum EUTF_ENCODE
{
EUTFE_NONE = 0,
EUTFE_UTF8,
EUTFE_UTF16,
EUTFE_UTF16_LE,
EUTFE_UTF16_BE,
EUTFE_UTF32,
EUTFE_UTF32_LE,
EUTFE_UTF32_BE
};
//! Unicode endianness.
enum EUTF_ENDIAN
{
EUTFEE_NATIVE = 0,
EUTFEE_LITTLE,
EUTFEE_BIG
};
//! Returns the specified unicode byte order mark in a byte array.
//! The byte order mark is the first few bytes in a text file that signifies its encoding.
/** \param mode The Unicode encoding method that we want to get the byte order mark for.
If EUTFE_UTF16 or EUTFE_UTF32 is passed, it uses the native system endianness. **/
//! \return An array that contains a byte order mark.
inline core::array<u8> getUnicodeBOM(EUTF_ENCODE mode)
{
#define COPY_ARRAY(source, size) \
memcpy(ret.pointer(), source, size); \
ret.set_used(size)
core::array<u8> ret(4);
switch (mode)
{
case EUTFE_UTF8:
COPY_ARRAY(BOM_ENCODE_UTF8, BOM_ENCODE_UTF8_LEN);
break;
case EUTFE_UTF16:
#ifdef __BIG_ENDIAN__
COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
#else
COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
#endif
break;
case EUTFE_UTF16_BE:
COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
break;
case EUTFE_UTF16_LE:
COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
break;
case EUTFE_UTF32:
#ifdef __BIG_ENDIAN__
COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
#else
COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
#endif
break;
case EUTFE_UTF32_BE:
COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
break;
case EUTFE_UTF32_LE:
COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
break;
case EUTFE_NONE:
// TODO sapier: fixed warning only,
// don't know if something needs to be done here
break;
}
return ret;
#undef COPY_ARRAY
}
//! Detects if the given data stream starts with a unicode BOM.
//! \param data The data stream to check.
//! \return The unicode BOM associated with the data stream, or EUTFE_NONE if none was found.
inline EUTF_ENCODE determineUnicodeBOM(const char* data)
{
if (memcmp(data, BOM_ENCODE_UTF8, 3) == 0) return EUTFE_UTF8;
if (memcmp(data, BOM_ENCODE_UTF16_BE, 2) == 0) return EUTFE_UTF16_BE7rQs?]?~Q)@9U&$& #d=5|[+ߓ??? 4Mn\~;M|ӑ'k/~[oSw~_[JW;]Q sSgW (?\~twZfw*?W X?)MXKˣ 6zF=zi }+F}h] c9eLc:fĘ1L3mcY?fϘ[>] ={tqgu}av_={q {t?L_c?~gNqs qό{Ըύq_ q5w}gǏ?j3 oL?u s&̛x '<=4&|䉓2蔉S^3uԩS/zN78mдN0mҴ ]:myM[1iOiMi4>}$G r8c돽؏ر;sf| Gs
?-4 sZSW,hbq1iaЌ7fӷA3rhO{OO4#hF<< 4cӌOf|N3~4B3^ Q=p#F =nЌЌK3f3iƘ5cɘ5c698uMЌy#fLf}˚{khFKЌ{\nq{j;ǽg/,4 <Ќo45cЌ'Ȅ +'l S&zщG pϿ~????z_~_~/Ƌ_x/ |oЋ=/~qg.g8k_Uxł-? ?jр 5 ^8¿{/|텯ֿ/,ya _Xz.~a _z|ߏKGȿ G? y #?=G~r䯎G| / _;#o97 y͑G 9?x>}uϿ{۟o~~=??!7??7 pwpןg~'|ۿ~VoosG[ܬ~ns>wsS;ӟ\swݿG=/}7?{K.w=>䏛OMSaSTnl(˟ #s KDZ~*t_WyI~&!GF6J0 ב35Oj>sm
///------------------///
//! Access an element in a unicode string, allowing one to change it.
class _ustring16_iterator_access
{
public:
_ustring16_iterator_access(const ustring16<TAlloc>* s, u32 p) : ref(s), pos(p) {}
//! Allow the class to be interpreted as a single UTF-32 character.
operator uchar32_t() const
{
return _get();
}
//! Allow one to change the character in the unicode string.
//! \param c The new character to use.
//! \return Myself.
_ustring16_iterator_access& operator=(const uchar32_t c)
{
_set(c);
return *this;
}
//! Increments the value by 1.
//! \return Myself.
_ustring16_iterator_access& operator++()
{
_set(_get() + 1);
return *this;
}
//! Increments the value by 1, returning the old value.
//! \return A unicode character.
uchar32_t operator++(int)
{
uchar32_t old = _get();
_set(old + 1);
return old;
}
//! Decrements the value by 1.
//! \return Myself.
_ustring16_iterator_access& operator--()
{
_set(_get() - 1);
return *this;
}
//! Decrements the value by 1, returning the old value.
//! \return A unicode character.
uchar32_t operator--(int)
{
uchar32_t old = _get();
_set(old - 1);
return old;
}
//! Adds to the value by a specified amount.
//! \param val The amount to add to this character.
//! \return Myself.
_ustring16_iterator_access& operator+=(int val)
{
_set(_get() + val);
return *this;
}
//! Subtracts from the value by a specified amount.
//! \param val The amount to subtract from this character.
//! \return Myself.
_ustring16_iterator_access& operator-=(int val)
{
_set(_get() - val);
return *this;
}
//! Multiples the value by a specified amount.
//! \param val The amount to multiply this character by.
//! \return Myself.
_ustring16_iterator_access& operator*=(int val)
{
_set(_get() * val);
return *this;
}
//! Divides the value by a specified amount.
//! \param val The amount to divide this character by.
//! \return Myself.
_ustring16_iterator_access& operator/=(int val)
{
_set(_get() / val);
return *this;
}
//! Modulos the value by a specified amount.
//! \param val The amount to modulo this character by.
//! \return Myself.
_ustring16_iterator_access& operator%=(int val)
{
_set(_get() % val);
return *this;
}
//! Adds to the value by a specified amount.
//! \param val The amount to add to this character.
//! \return A unicode character.
uchar32_t operator+(int val) const
{
return _get() + val;
}
//! Subtracts from the value by a specified amount.
//! \param val The amount to subtract from this character.
//! \return A unicode character.
uchar32_t operator-(int val) const
{
return _get() - val;
}
//! Multiplies the value by a specified amount.
//! \param val The amount to multiply this character by.
//! \return A unicode character.
uchar32_t operator*(int val) const
{
return _get() * val;
}
//! Divides the value by a specified amount.
//! \param val The amount to divide this character by.
//! \return A unicode character.
uchar32_t operator/(int val) const
{
return _get() / val;
}
//! Modulos the value by a specified amount.
//! \param val The amount to modulo this character by.
//! \return A unicode character.
uchar32_t operator%(int val) const
{
return _get() % val;
}
private:
//! Gets a uchar32_t from our current position.
uchar32_t _get() const
{
const uchar16_t* a = ref->c_str();
if (!UTF16_IS_SURROGATE(a[pos]))
return static_cast<uchar32_t>(a[pos]);
else
{
if (pos + 1 >= ref->size_raw())
return 0;
return unicode::toUTF32(a[pos], a[pos + 1]);
}
}
//! Sets a uchar32_t at our current position.
void _set(uchar32_t c)
{
ustring16<TAlloc>* ref2 = const_cast<ustring16<TAlloc>*>(ref);
const uchar16_t* a = ref2->c_str();
if (c > 0xFFFF)
{
// c will be multibyte, so split it up into the high and low surrogate pairs.
uchar16_t x = static_cast<uchar16_t>(c);
uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
// If the previous position was a surrogate pair, just replace them. Else, insert the low pair.
if (UTF16_IS_SURROGATE_HI(a[pos]) && pos + 1 != ref2->size_raw())
ref2->replace_raw(vl, static_cast<u32>(pos) + 1);
else ref2->insert_raw(vl, static_cast<u32>(pos) + 1);
ref2->replace_raw(vh, static_cast<u32>(pos));
}
else
{
// c will be a single byte.
uchar16_t vh = static_cast<uchar16_t>(c);
// If the previous position was a surrogate pair, remove the extra byte.
if (UTF16_IS_SURROGATE_HI(a[pos]))
ref2->erase_raw(static_cast<u32>(pos) + 1);
ref2->replace_raw(vh, static_cast<u32>(pos));
}
}
const ustring16<TAlloc>* ref;
u32 pos;
};
typedef typename ustring16<TAlloc>::_ustring16_iterator_access access;
//! Iterator to iterate through a UTF-16 string.
#ifndef USTRING_NO_STL
class _ustring16_const_iterator : public std::iterator<
std::bidirectional_iterator_tag, // iterator_category
access, // value_type
ptrdiff_t, // difference_type
const access, // pointer
const access // reference
>
#else
class _ustring16_const_iterator
#endif
{
public:
typedef _ustring16_const_iterator _Iter;
typedef std::iterator<std::bidirectional_iterator_tag, access, ptrdiff_t, const access, const access> _Base;
typedef const access const_pointer;
typedef const access const_reference;
#ifndef USTRING_NO_STL
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::difference_type distance_type;
typedef typename _Base::pointer pointer;
typedef const_reference reference;
#else
typedef access value_type;
typedef u32 difference_type;
typedef u32 distance_type;
typedef const_pointer pointer;
typedef const_reference reference;
#endif
//! Constructors.
_ustring16_const_iterator(const _Iter& i) : ref(i.ref), pos(i.pos) {}
_ustring16_const_iterator(const ustring16<TAlloc>& s) : ref(&s), pos(0) {}
_ustring16_const_iterator(const ustring16<TAlloc>& s, const u32 p) : ref(&s), pos(0)
{
if (ref->size_raw() == 0 || p == 0)
return;
// Go to the appropriate position.
u32 i = p;
u32 sr = ref->size_raw();
const uchar16_t* a = ref->c_str();
while (i != 0 && pos < sr)
{
if (UTF16_IS_SURROGATE_HI(a[pos]))
pos += 2;
else ++pos;
--i;
}
}
//! Test for equalness.
bool operator==(const _Iter& iter) const
{
if (ref == iter.ref && pos == iter.pos)
return true;
return false;
}
//! Test for unequalness.
bool operator!=(const _Iter& iter) const
{
if (ref != iter.ref || pos != iter.pos)
return true;
return false;
}
//! Switch to the next full character in the string.
_Iter& operator++()
{ // ++iterator
if (pos == ref->size_raw()) return *this;
const uchar16_t* a = ref->c_str();
if (UTF16_IS_SURROGATE_HI(a[pos]))
pos += 2; // TODO: check for valid low surrogate?
else ++pos;
if (pos > ref->size_raw()) pos = ref->size_raw();
return *this;
}
//! Switch to the next full character in the string, returning the previous position.
_Iter operator++(int)
{ // iterator++
_Iter _tmp(*this);
++*this;
return _tmp;
}
//! Switch to the previous full character in the string.
_Iter& operator--()
{ // --iterator
if (pos == 0) return *this;
const uchar16_t* a = ref->c_str();
--pos;
if (UTF16_IS_SURROGATE_LO(a[pos]) && pos != 0) // low surrogate, go back one more.
--pos;
return *this;
}
//! Switch to the previous full character in the string, returning the previous position.
_Iter operator--(int)
{ // iterator--
_Iter _tmp(*this);
--*this;
return _tmp;
}
//! Advance a specified number of full characters in the string.
//! \return Myself.
_Iter& operator+=(const difference_type v)
{
if (v == 0) return *this;
if (v < 0) return operator-=(v * -1);
if (pos >= ref->size_raw())
return *this;
// Go to the appropriate position.
// TODO: Don't force u32 on an x64 OS. Make it agnostic.
u32 i = (u32)v;
u32 sr = ref->size_raw();
const uchar16_t* a = ref->c_str();
while (i != 0 && pos < sr)
{
if (UTF16_IS_SURROGATE_HI(a[pos]))
pos += 2;
else ++pos;
--i;
}
if (pos > sr)
pos = sr;
return *this;
}
//! Go back a specified number of full characters in the string.
//! \return Myself.
_Iter& operator-=(const difference_type v)
{
if (v == 0) return *this;
if (v > 0) return operator+=(v * -1);
if (pos == 0)
return *this;
// Go to the appropriate position.
// TODO: Don't force u32 on an x64 OS. Make it agnostic.
u32 i = (u32)v;
const uchar16_t* a = ref->c_str();
while (i != 0 && pos != 0)
{
--pos;
if (UTF16_IS_SURROGATE_LO(a[pos]) != 0 && pos != 0)
--pos;
--i;
}
return *this;
}
//! Return a new iterator that is a variable number of full characters forward from the current position.
_Iter operator+(const difference_type v) const
{
_Iter ret(*this);
ret += v;
return ret;
}
//! Return a new iterator that is a variable number of full characters backward from the current position.
_Iter operator-(const difference_type v) const
{
_Iter ret(*this);
ret -= v;
return ret;
}
//! Returns the distance between two iterators.
difference_type operator-(const _Iter& iter) const
{
// Make sure we reference the same object!
if (ref != iter.ref)
return difference_type();
_Iter i = iter;
difference_type ret;
// Walk up.
if (pos > i.pos)
{
while (pos > i.pos)
{
++i;
++ret;
}
return ret;
}
// Walk down.
while (pos < i.pos)
{
--i;
--ret;
}
return ret;
}
//! Accesses the full character at the iterator's position.
const_reference operator*() const
{
if (pos >= ref->size_raw())
{
const uchar16_t* a = ref->c_str();
u32 p = ref->size_raw();
if (UTF16_IS_SURROGATE_LO(a[p]))
--p;
reference ret(ref, p);
return ret;
}
const_reference ret(ref, pos);
return ret;
}
//! Accesses the full character at the iterator's position.
reference operator*()
{
if (pos >= ref->size_raw())
{
const uchar16_t* a = ref->c_str();
u32 p = ref->size_raw();
if (UTF16_IS_SURROGATE_LO(a[p]))
--p;
reference ret(ref, p);
return ret;
}
reference ret(ref, pos);
return ret;
}
//! Accesses the full character at the iterator's position.
const_pointer operator->() const
{
return operator*();
}
//! Accesses the full character at the iterator's position.
pointer operator->()
{
return operator*();
}
//! Is the iterator at the start of the string?
bool atStart() const
{
return pos == 0;
}
//! Is the iterator at the end of the string?
bool atEnd() const
{
const uchar16_t* a = ref->c_str();
if (UTF16_IS_SURROGATE(a[pos]))
return (pos + 1) >= ref->size_raw();
else return pos >= ref->size_raw();
}
//! Moves the iterator to the start of the string.
void toStart()
{
pos = 0;
}
//! Moves the iterator to the end of the string.
void toEnd()
{
pos = ref->size_raw();
}
//! Returns the iterator's position.
//! \return The iterator's position.
u32 getPos() const
{
return pos;
}
protected:
const ustring16<TAlloc>* ref;
u32 pos;
};
//! Iterator to iterate through a UTF-16 string.
class _ustring16_iterator : public _ustring16_const_iterator
{
public:
typedef _ustring16_iterator _Iter;
typedef _ustring16_const_iterator _Base;
typedef typename _Base::const_pointer const_pointer;
typedef typename _Base::const_reference const_reference;
typedef typename _Base::value_type value_type;
typedef typename _Base::difference_type difference_type;
typedef typename _Base::distance_type distance_type;
typedef access pointer;
typedef access reference;
using _Base::pos;
using _Base::ref;
//! Constructors.
_ustring16_iterator(const _Iter& i) : _ustring16_const_iterator(i) {}
_ustring16_iterator(const ustring16<TAlloc>& s) : _ustring16_const_iterator(s) {}
_ustring16_iterator(const ustring16<TAlloc>& s, const u32 p) : _ustring16_const_iterator(s, p) {}
//! Accesses the full character at the iterator's position.
reference operator*() const
{
if (pos >= ref->size_raw())
{
const uchar16_t* a = ref->c_str();
u32 p = ref->size_raw();
if (UTF16_IS_SURROGATE_LO(a[p]))
--p;
reference ret(ref, p);
return ret;
}
reference ret(ref, pos);
return ret;
}
//! Accesses the full character at the iterator's position.
reference operator*()
{
if (pos >= ref->size_raw())
{
const uchar16_t* a = ref->c_str();
u32 p = ref->size_raw();
if (UTF16_IS_SURROGATE_LO(a[p]))
--p;
reference ret(ref, p);
return ret;
}
reference ret(ref, pos);
return ret;
}
//! Accesses the full character at the iterator's position.
pointer operator->() const
{
return operator*();
}
//! Accesses the full character at the iterator's position.
pointer operator->()
{
return operator*();
}
};
typedef typename ustring16<TAlloc>::_ustring16_iterator iterator;
typedef typename ustring16<TAlloc>::_ustring16_const_iterator const_iterator;
///----------------------///
/// end iterator classes ///
///----------------------///
//! Default constructor
ustring16()
: array(0), allocated(1), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
array = allocator.allocate(1); // new u16[1];
array[0] = 0x0;
}
//! Constructor
ustring16(const ustring16<TAlloc>& other)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
*this = other;
}
//! Constructor from other string types
template <class B, class A>
ustring16(const string<B, A>& other)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
*this = other;
}
#ifndef USTRING_NO_STL
//! Constructor from std::string
template <class B, class A, typename Alloc>
ustring16(const std::basic_string<B, A, Alloc>& other)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
*this = other.c_str();
}
//! Constructor from iterator.
template <typename Itr>
ustring16(Itr first, Itr last)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
reserve(std::distance(first, last));
array[used] = 0;
for (; first != last; ++first)
append((uchar32_t)*first);
}
#endif
#ifndef USTRING_CPP0X_NEWLITERALS
//! Constructor for copying a character string from a pointer.
ustring16(const char* const c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
loadDataStream(c, strlen(c));
//append((uchar8_t*)c);
}
//! Constructor for copying a character string from a pointer with a given length.
ustring16(const char* const c, u32 length)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
loadDataStream(c, length);
}
#endif
//! Constructor for copying a UTF-8 string from a pointer.
ustring16(const uchar8_t* const c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c);
}
//! Constructor for copying a UTF-8 string from a single char.
ustring16(const char c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append((uchar32_t)c);
}
//! Constructor for copying a UTF-8 string from a pointer with a given length.
ustring16(const uchar8_t* const c, u32 length)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c, length);
}
//! Constructor for copying a UTF-16 string from a pointer.
ustring16(const uchar16_t* const c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c);
}
//! Constructor for copying a UTF-16 string from a pointer with a given length
ustring16(const uchar16_t* const c, u32 length)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c, length);
}
//! Constructor for copying a UTF-32 string from a pointer.
ustring16(const uchar32_t* const c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c);
}
//! Constructor for copying a UTF-32 from a pointer with a given length.
ustring16(const uchar32_t* const c, u32 length)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
append(c, length);
}
//! Constructor for copying a wchar_t string from a pointer.
ustring16(const wchar_t* const c)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
if (sizeof(wchar_t) == 4)
append(reinterpret_cast<const uchar32_t* const>(c));
else if (sizeof(wchar_t) == 2)
append(reinterpret_cast<const uchar16_t* const>(c));
else if (sizeof(wchar_t) == 1)
append(reinterpret_cast<const uchar8_t* const>(c));
}
//! Constructor for copying a wchar_t string from a pointer with a given length.
ustring16(const wchar_t* const c, u32 length)
: array(0), allocated(0), used(0)
{
#if __BYTE_ORDER == __BIG_ENDIAN
encoding = unicode::EUTFE_UTF16_BE;
#else
encoding = unicode::EUTFE_UTF16_LE;
#endif
if (sizeof(wchar_t) == 4)
append(reinterpret_cast<const uchar32_t* const>(c), length);
else if (sizeof(wchar_t) == 2)
append(reinterpret_cast<const uchar16_t* const>(c), length);
else if (sizeof(wchar_t) == 1)
append(reinterpret_cast<const uchar8_t* const>(c), length);
}
#ifdef USTRING_CPP0X
//! Constructor for moving a ustring16
ustring16(ustring16<TAlloc>&& other)
: array(other.array), encoding(other.encoding), allocated(other.allocated), used(other.used)
{
//std::cout << "MOVE constructor" << std::endl;
other.array = 0;
other.allocated = 0;
other.used = 0;
}
#endif
//! Destructor
~ustring16()
{
allocator.deallocate(array); // delete [] array;
}
//! Assignment operator
ustring16& operator=(const ustring16<TAlloc>& other)
{
if (this == &other)
return *this;
used = other.size_raw();
if (used >= allocated)
{
allocator.deallocate(array); // delete [] array;
allocated = used + 1;
array = allocator.allocate(used + 1); //new u16[used];
}
const uchar16_t* p = other.c_str();
for (u32 i=0; i<=used; ++i, ++p)
array[i] = *p;
array[used] = 0;
// Validate our new UTF-16 string.
validate();
return *this;
}
#ifdef USTRING_CPP0X
//! Move assignment operator
ustring16& operator=(ustring16<TAlloc>&& other)
{
if (this != &other)
{
//std::cout << "MOVE operator=" << std::endl;
allocator.deallocate(array);
array = other.array;
allocated = other.allocated;
encoding = other.encoding;
used = other.used;
other.array = 0;
other.used = 0;
}
return *this;
}
#endif
//! Assignment operator for other string types
template <class B, class A>
ustring16<TAlloc>& operator=(const string<B, A>& other)
{
*this = other.c_str();
return *this;
}
//! Assignment operator for UTF-8 strings
ustring16<TAlloc>& operator=(const uchar8_t* const c)
{
if (!array)
{
array = allocator.allocate(1); //new u16[1];
allocated = 1;
}
used = 0;
array[used] = 0x0;
if (!c) return *this;
//! Append our string now.
append(c);
return *this;
}
//! Assignment operator for UTF-16 strings
ustring16<TAlloc>& operator=(const uchar16_t* const c)
{
if (!array)
{
array = allocator.allocate(1); //new u16[1];
allocated = 1;
}
used = 0;
array[used] = 0x0;
if (!c) return *this;
//! Append our string now.
append(c);
return *this;
}
//! Assignment operator for UTF-32 strings
ustring16<TAlloc>& operator=(const uchar32_t* const c)
{
if (!array)
{
array = allocator.allocate(1); //new u16[1];
allocated = 1;
}
used = 0;
array[used] = 0x0;
if (!c) return *this;
//! Append our string now.
append(c);
return *this;
}
//! Assignment operator for wchar_t strings.
/** Note that this assumes that a correct unicode string is stored in the wchar_t string.
Since wchar_t changes depending on its platform, it could either be a UTF-8, -16, or -32 string.
This function assumes you are storing the correct unicode encoding inside the wchar_t string. **/
ustring16<TAlloc>& operator=(const wchar_t* const c)
{
if (sizeof(wchar_t) == 4)
*this = reinterpret_cast<const uchar32_t* const>(c);
else if (sizeof(wchar_t) == 2)
*this = reinterpret_cast<const uchar16_t* const>(c);
else if (sizeof(wchar_t) == 1)
*this = reinterpret_cast<const uchar8_t* const>(c);
return *this;
}
//! Assignment operator for other strings.
/** Note that this assumes that a correct unicode string is stored in the string. **/
template <class B>
ustring16<TAlloc>& operator=(const B* const c)
{
if (sizeof(B) == 4)
*this = reinterpret_cast<const uchar32_t* const>(c);
else if (sizeof(B) == 2)
*this = reinterpret_cast<const uchar16_t* const>(c);
else if (sizeof(B) == 1)
*this = reinterpret_cast<const uchar8_t* const>(c);
return *this;
}
//! Direct access operator
access operator [](const u32 index)
{
_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
iterator iter(*this, index);
return iter.operator*();
}
//! Direct access operator
const access operator [](const u32 index) const
{
_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
const_iterator iter(*this, index);
return iter.operator*();
}
//! Equality operator
bool operator ==(const uchar16_t* const str) const
{
if (!str)
return false;
u32 i;
for(i=0; array[i] && str[i]; ++i)
if (array[i] != str[i])
return false;
return !array[i] && !str[i];
}
//! Equality operator
bool operator ==(const ustring16<TAlloc>& other) const
{
for(u32 i=0; array[i] && other.array[i]; ++i)
if (array[i] != other.array[i])
return false;
return used == other.used;
}
//! Is smaller comparator
bool operator <(const ustring16<TAlloc>& other) const
{
for(u32 i=0; array[i] && other.array[i]; ++i)
{
s32 diff = array[i] - other.array[i];
if ( diff )
return diff < 0;
}
return used < other.used;
}
//! Inequality operator
bool operator !=(const uchar16_t* const str) const
{
return !(*this == str);
}
//! Inequality operator
bool operator !=(const ustring16<TAlloc>& other) const
{
return !(*this == other);
}
//! Returns the length of a ustring16 in full characters.
//! \return Length of a ustring16 in full characters.
u32 size() const
{
const_iterator i(*this, 0);
u32 pos = 0;
while (!i.atEnd())
{
++i;
++pos;
}
return pos;
}
//! Informs if the ustring is empty or not.
//! \return True if the ustring is empty, false if not.
bool empty() const
{
return (size_raw() == 0);
}
//! Returns a pointer to the raw UTF-16 string data.
//! \return pointer to C-style NUL terminated array of UTF-16 code points.
const uchar16_t* c_str() const
{
return array;
}
//! Compares the first n characters of this string with another.
//! \param other Other string to compare to.
//! \param n Number of characters to compare.
//! \return True if the n first characters of both strings are equal.
bool equalsn(const ustring16<TAlloc>& other, u32 n) const
{
u32 i;
const uchar16_t* oa = other.c_str();
for(i=0; array[i] && oa[i] && i < n; ++i)
if (array[i] != oa[i])
return false;
// if one (or both) of the strings was smaller then they
// are only equal if they have the same length
return (i == n) || (used == other.used);
}
//! Compares the first n characters of this string with another.
//! \param str Other string to compare to.
//! \param n Number of characters to compare.
//! \return True if the n first characters of both strings are equal.
bool equalsn(const uchar16_t* const str, u32 n) const
{
if (!str)
return false;
u32 i;
for(i=0; array[i] && str[i] && i < n; ++i)
if (array[i] != str[i])
return false;
// if one (or both) of the strings was smaller then they
// are only equal if they have the same length
return (i == n) || (array[i] == 0 && str[i] == 0);
}
//! Appends a character to this ustring16
//! \param character The character to append.
//! \return A reference to our current string.
ustring16<TAlloc>& append(uchar32_t character)
{
if (used + 2 >= allocated)
reallocate(used + 2);
if (character > 0xFFFF)
{
used += 2;
// character will be multibyte, so split it up into a surrogate pair.
uchar16_t x = static_cast<uchar16_t>(character);
uchar16_t vh = UTF16_HI_SURROGATE | ((((character >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
array[used-2] = vh;
array[used-1] = vl;
}
else
{
++used;
array[used-1] = character;
}
array[used] = 0;
return *this;
}
//! Appends a UTF-8 string to this ustring16
//! \param other The UTF-8 string to append.
//! \param length The length of the string to append.
//! \return A reference to our current string.
ustring16<TAlloc>& append(const uchar8_t* const other, u32 length=0xffffffff)
{
if (!other)
return *this;
// Determine if the string is long enough for a BOM.
u32 len = 0;
const uchar8_t* p = other;
do
{
++len;
} while (*p++ && len < unicode::BOM_ENCODE_UTF8_LEN);
// Check for BOM.
unicode::EUTF_ENCODE c_bom = unicode::EUTFE_NONE;
if (len == unicode::BOM_ENCODE_UTF8_LEN)
{
if (memcmp(other, unicode::BOM_ENCODE_UTF8, unicode::BOM_ENCODE_UTF8_LEN) == 0)
c_bom = unicode::EUTFE_UTF8;
}
// If a BOM was found, don't include it in the string.
const uchar8_t* c2 = other;
if (c_bom != unicode::EUTFE_NONE)
{
c2 = other + unicode::BOM_UTF8_LEN;
length -= unicode::BOM_UTF8_LEN;
}
// Calculate the size of the string to read in.
len = 0;
p = c2;
do
{
++len;
} while(*p++ && len < length);
if (len > length)
len = length;
// If we need to grow the array, do it now.
if (used + len >= allocated)
reallocate(used + (len * 2));
u32 start = used;
// Convert UTF-8 to UTF-16.
u32 pos = start;
for (u32 l = 0; l<len;)
{
++used;
if (((c2[l] >> 6) & 0x03) == 0x02)
{ // Invalid continuation byte.
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
++l;
}
else if (c2[l] == 0xC0 || c2[l] == 0xC1)
{ // Invalid byte - overlong encoding.
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
++l;
}
else if ((c2[l] & 0xF8) == 0xF0)
{ // 4 bytes UTF-8, 2 bytes UTF-16.
// Check for a full string.
if ((l + 3) >= len)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
l += 3;
break;
}
// Validate.
bool valid = true;
u8 l2 = 0;
if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
if (valid && (((c2[l+3] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
if (!valid)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
l += l2;
continue;
}
// Decode.
uchar8_t b1 = ((c2[l] & 0x7) << 2) | ((c2[l+1] >> 4) & 0x3);
uchar8_t b2 = ((c2[l+1] & 0xF) << 4) | ((c2[l+2] >> 2) & 0xF);
uchar8_t b3 = ((c2[l+2] & 0x3) << 6) | (c2[l+3] & 0x3F);
uchar32_t v = b3 | ((uchar32_t)b2 << 8) | ((uchar32_t)b1 << 16);
// Split v up into a surrogate pair.
uchar16_t x = static_cast<uchar16_t>(v);
uchar16_t vh = UTF16_HI_SURROGATE | ((((v >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
array[pos++] = vh;
array[pos++] = vl;
l += 4;
++used; // Using two shorts this time, so increase used by 1.
}
else if ((c2[l] & 0xF0) == 0xE0)
{ // 3 bytes UTF-8, 1 byte UTF-16.
// Check for a full string.
if ((l + 2) >= len)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
l += 2;
break;
}
// Validate.
bool valid = true;
u8 l2 = 0;
if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
if (!valid)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
l += l2;
continue;
}
// Decode.
uchar8_t b1 = ((c2[l] & 0xF) << 4) | ((c2[l+1] >> 2) & 0xF);
uchar8_t b2 = ((c2[l+1] & 0x3) << 6) | (c2[l+2] & 0x3F);
uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
array[pos++] = ch;
l += 3;
}
else if ((c2[l] & 0xE0) == 0xC0)
{ // 2 bytes UTF-8, 1 byte UTF-16.
// Check for a full string.
if ((l + 1) >= len)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
l += 1;
break;
}
// Validate.
if (((c2[l+1] >> 6) & 0x03) != 0x02)
{
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
++l;
continue;
}
// Decode.
uchar8_t b1 = (c2[l] >> 2) & 0x7;
uchar8_t b2 = ((c2[l] & 0x3) << 6) | (c2[l+1] & 0x3F);
uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
array[pos++] = ch;
l += 2;
}
else
{ // 1 byte UTF-8, 1 byte UTF-16.
// Validate.
if (c2[l] > 0x7F)
{ // Values above 0xF4 are restricted and aren't used. By now, anything above 0x7F is invalid.
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
}
else array[pos++] = static_cast<uchar16_t>(c2[l]);
++l;
}
}
array[used] = 0;
// Validate our new UTF-16 string.
validate();
return *this;
}
//! Appends a UTF-16 string to this ustring16
//! \param other The UTF-16 string to append.
//! \param length The length of the string to append.
//! \return A reference to our current string.
ustring16<TAlloc>& append(const uchar16_t* const other, u32 length=0xffffffff)
{
if (!other)
return *this;
// Determine if the string is long enough for a BOM.
u32 len = 0;
const uchar16_t* p = other;
do
{
++len;
} while (*p++ && len < unicode::BOM_ENCODE_UTF16_LEN);
// Check for the BOM to determine the string's endianness.
unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
if (memcmp(other, unicode::BOM_ENCODE_UTF16_LE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
c_end = unicode::EUTFEE_LITTLE;
else if (memcmp(other, unicode::BOM_ENCODE_UTF16_BE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
c_end = unicode::EUTFEE_BIG;
// If a BOM was found, don't include it in the string.
const uchar16_t* c2 = other;
if (c_end != unicode::EUTFEE_NATIVE)
{
c2 = other + unicode::BOM_UTF16_LEN;
length -= unicode::BOM_UTF16_LEN;
}
// Calculate the size of the string to read in.
len = 0;
p = c2;
do
{
++len;
} while(*p++ && len < length);
if (len > length)
len = length;
// If we need to grow the size of the array, do it now.
if (used + len >= allocated)
reallocate(used + (len * 2));
u32 start = used;
used += len;
// Copy the string now.
unicode::EUTF_ENDIAN m_end = getEndianness();
for (u32 l = start; l < start + len; ++l)
{
array[l] = (uchar16_t)c2[l];
if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
array[l] = unicode::swapEndian16(array[l]);
}
array[used] = 0;
// Validate our new UTF-16 string.
validate();
return *this;
}
//! Appends a UTF-32 string to this ustring16
//! \param other The UTF-32 string to append.
//! \param length The length of the string to append.
//! \return A reference to our current string.
ustring16<TAlloc>& append(const uchar32_t* const other, u32 length=0xffffffff)
{
if (!other)
return *this;
// Check for the BOM to determine the string's endianness.
unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
if (memcmp(other, unicode::BOM_ENCODE_UTF32_LE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
c_end = unicode::EUTFEE_LITTLE;
else if (memcmp(other, unicode::BOM_ENCODE_UTF32_BE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
c_end = unicode::EUTFEE_BIG;
// If a BOM was found, don't include it in the string.
const uchar32_t* c2 = other;
if (c_end != unicode::EUTFEE_NATIVE)
{
c2 = other + unicode::BOM_UTF32_LEN;
length -= unicode::BOM_UTF32_LEN;
}
// Calculate the size of the string to read in.
u32 len = 0;
const uchar32_t* p = c2;
do
{
++len;
} while(*p++ && len < length);
if (len > length)
len = length;
// If we need to grow the size of the array, do it now.
// In case all of the UTF-32 string is split into surrogate pairs, do len * 2.
if (used + (len * 2) >= allocated)
reallocate(used + ((len * 2) * 2));
u32 start = used;
// Convert UTF-32 to UTF-16.
unicode::EUTF_ENDIAN m_end = getEndianness();
u32 pos = start;
for (u32 l = 0; l<len; ++l)
{
++used;
uchar32_t ch = c2[l];
if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
ch = unicode::swapEndian32(ch);
if (ch > 0xFFFF)
{
// Split ch up into a surrogate pair as it is over 16 bits long.
uchar16_t x = static_cast<uchar16_t>(ch);
uchar16_t vh = UTF16_HI_SURROGATE | ((((ch >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
array[pos++] = vh;
array[pos++] = vl;
++used; // Using two shorts, so increased used again.
}
else if (ch >= 0xD800 && ch <= 0xDFFF)
{
// Between possible UTF-16 surrogates (invalid!)
array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
}
else array[pos++] = static_cast<uchar16_t>(ch);
}
array[used] = 0;
// Validate our new UTF-16 string.
validate();
return *this;
}
//! Appends a ustring16 to this ustring16
//! \param other The string to append to this one.
//! \return A reference to our current string.
ustring16<TAlloc>& append(const ustring16<TAlloc>& other)
{
const uchar16_t* oa = other.c_str();
u32 len = other.size_raw();
if (used + len >= allocated)
reallocate(used + len);
for (u32 l=0; l<len; ++l)
array[used+l] = oa[l];
used += len;
array[used] = 0;
return *this;
}
//! Appends a certain amount of characters of a ustring16 to this ustring16.
//! \param other The string to append to this one.
//! \param length How many characters of the other string to add to this one.
//! \return A reference to our current string.
ustring16<TAlloc>& append(const ustring16<TAlloc>& other, u32 length)
{
if (other.size() == 0)
return *this;
if (other.size() < length)
{
append(other);
return *this;
}
if (used + length * 2 >= allocated)
reallocate(used + length * 2);
const_iterator iter(other, 0);
u32 l = length;
while (!iter.atEnd() && l)
{
uchar32_t c = *iter;
append(c);
++iter;
--l;
}
return *this;
}
//! Reserves some memory.
//! \param count The amount of characters to reserve.
void reserve(u32 count)
{
if (count < allocated)
return;
reallocate(count);
}
//! Finds first occurrence of character.
//! \param c The character to search for.
//! \return Position where the character has been found, or -1 if not found.
s32 findFirst(uchar32_t c) const
{
const_iterator i(*this, 0);
s32 pos = 0;
while (!i.atEnd())
{
uchar32_t t = *i;
if (c == t)
return pos;
++pos;
++i;
}
return -1;
}
//! Finds first occurrence of a character of a list.
//! \param c A list of characters to find. For example if the method should find the first occurrence of 'a' or 'b', this parameter should be "ab".
//! \param count The amount of characters in the list. Usually, this should be strlen(c).
//! \return Position where one of the characters has been found, or -1 if not found.
s32 findFirstChar(const uchar32_t* const c, u32 count=1) const
{
if (!c || !count)
return -1;
const_iterator i(*this, 0);
s32 pos = 0;
while (!i.atEnd())
{
uchar32_t t = *i;
for (u32 j=0; j<count; ++j)
if (t == c[j])
return pos;
++pos;
++i;
}
return -1;
}
//! Finds first position of a character not in a given list.
//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
//! \param count The amount of characters in the list. Usually, this should be strlen(c).
//! \return Position where the character has been found, or -1 if not found.
s32 findFirstCharNotInList(const uchar32_t* const c, u32 count=1) const
{
if (!c || !count)
return -1;
const_iterator i(*this, 0);
s32 pos = 0;
while (!i.atEnd())
{
uchar32_t t = *i;
u32 j;
for (j=0; j<count; ++j)
if (t == c[j])
break;
if (j==count)
return pos;
++pos;
++i;
}
return -1;
}
//! Finds last position of a character not in a given list.
//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
//! \param count The amount of characters in the list. Usually, this should be strlen(c).
//! \return Position where the character has been found, or -1 if not found.
s32 findLastCharNotInList(const uchar32_t* const c, u32 count=1) const
{
if (!c || !count)
return -1;
const_iterator i(end());
--i;
s32 pos = size() - 1;
while (!i.atStart())
{
uchar32_t t = *i;
u32 j;
for (j=0; j<count; ++j)
if (t == c[j])
break;
if (j==count)
return pos;
--pos;
--i;
}
return -1;
}
//! Finds next occurrence of character.
//! \param c The character to search for.
//! \param startPos The position in the string to start searching.
//! \return Position where the character has been found, or -1 if not found.
s32 findNext(uchar32_t c, u32 startPos) const
{
const_iterator i(*this, startPos);
s32 pos = startPos;
while (!i.atEnd())
{
uchar32_t t = *i;
if (t == c)
return pos;
++pos;
++i;
}
return -1;
}
//! Finds last occurrence of character.
//! \param c The character to search for.
//! \param start The start position of the reverse search ( default = -1, on end ).
//! \return Position where the character has been found, or -1 if not found.
s32 findLast(uchar32_t c, s32 start = -1) const
{
u32 s = size();
start = core::clamp ( start < 0 ? (s32)s : start, 0, (s32)s ) - 1;
const_iterator i(*this, start);
u32 pos = start;
while (!i.atStart())
{
uchar32_t t = *i;
if (t == c)
return pos;
--pos;
--i;
}
return -1;
}
//! Finds last occurrence of a character in a list.
//! \param c A list of strings to find. For example if the method should find the last occurrence of 'a' or 'b', this parameter should be "ab".
//! \param count The amount of characters in the list. Usually, this should be strlen(c).
//! \return Position where one of the characters has been found, or -1 if not found.
s32 findLastChar(const uchar32_t* const c, u32 count=1) const
{
if (!c || !count)
return -1;
const_iterator i(end());
--i;
s32 pos = size();
while (!i.atStart())
{
uchar32_t t = *i;
for (u32 j=0; j<count; ++j)
if (t == c[j])
return pos;
--pos;
--i;
}
return -1;
}
//! Finds another ustring16 in this ustring16.
//! \param str The string to find.
//! \param start The start position of the search.
//! \return Positions where the ustring16 has been found, or -1 if not found.
s32 find(const ustring16<TAlloc>& str, const u32 start = 0) const
{
u32 my_size = size();
u32 their_size = str.size();
if (their_size == 0 || my_size - start < their_size)
return -1;
const_iterator i(*this, start);
s32 pos = start;
while (!i.atEnd())
{
const_iterator i2(i);
const_iterator j(str, 0);
uchar32_t t1 = (uchar32_t)*i2;
uchar32_t t2 = (uchar32_t)*j;
while (t1 == t2)
{
++i2;
++j;
if (j.atEnd())
return pos;
t1 = (uchar32_t)*i2;
t2 = (uchar32_t)*j;
}
++i;
++pos;
}
return -1;
}
//! Finds another ustring16 in this ustring16.
//! \param str The string to find.
//! \param start The start position of the search.
//! \return Positions where the string has been found, or -1 if not found.
s32 find_raw(const ustring16<TAlloc>& str, const u32 start = 0) const
{
const uchar16_t* data = str.c_str();
if (data && *data)
{
u32 len = 0;
while (data[len])
++len;
if (len > used)
return -1;
for (u32 i=start; i<=used-len; ++i)
{
u32 j=0;
while(data[j] && array[i+j] == data[j])
++j;
if (!data[j])
return i;
}
}
return -1;
}
//! Returns a substring.
//! \param begin: Start of substring.
//! \param length: Length of substring.
//! \return A reference to our current string.
ustring16<TAlloc> subString(u32 begin, s32 length) const
{
u32 len = size();
// if start after ustring16
// or no proper substring length
if ((length <= 0) || (begin>=len))
return ustring16<TAlloc>("");
// clamp length to maximal value
if ((length+begin) > len)
length = len-begin;
ustring16<TAlloc> o;
o.reserve((length+1) * 2);
const_iterator i(*this, begin);
while (!i.atEnd() && length)
{
o.append(*i);
++i;
--length;
}
return o;
}
//! Appends a character to this ustring16.
//! \param c Character to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (char c)
{
append((uchar32_t)c);
return *this;
}
//! Appends a character to this ustring16.
//! \param c Character to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (uchar32_t c)
{
append(c);
return *this;
}
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (short c)
{
append(core::stringc(c));
return *this;
}
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (unsigned short c)
{
append(core::stringc(c));
return *this;
}
#ifdef USTRING_CPP0X_NEWLITERALS
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (int c)
{
append(core::stringc(c));
return *this;
}
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (unsigned int c)
{
append(core::stringc(c));
return *this;
}
#endif
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (long c)
{
append(core::stringc(c));
return *this;
}
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (unsigned long c)
{
append(core::stringc(c));
return *this;
}
//! Appends a number to this ustring16.
//! \param c Number to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (double c)
{
append(core::stringc(c));
return *this;
}
//! Appends a char ustring16 to this ustring16.
//! \param c Char ustring16 to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (const uchar16_t* const c)
{
append(c);
return *this;
}
//! Appends a ustring16 to this ustring16.
//! \param other ustring16 to append.
//! \return A reference to our current string.
ustring16<TAlloc>& operator += (const ustring16<TAlloc>& other)
{
append(other);
return *this;
}
//! Replaces all characters of a given type with another one.
//! \param toReplace Character to replace.
//! \param replaceWith Character replacing the old one.
//! \return A reference to our current string.
ustring16<TAlloc>& replace(uchar32_t toReplace, uchar32_t replaceWith)
{
iterator i(*this, 0);
while (!i.atEnd())
{
typename ustring16<TAlloc>::access a = *i;
if ((uchar32_t)a == toReplace)
a = replaceWith;
++i;
}
return *this;
}
//! Replaces all instances of a string with another one.
//! \param toReplace The string to replace.
//! \param replaceWith The string replacing the old one.
//! \return A reference to our current string.
ustring16<TAlloc>& replace(const ustring16<TAlloc>& toReplace, const ustring16<TAlloc>& replaceWith)
{
if (toReplace.size() == 0)
return *this;
const uchar16_t* other = toReplace.c_str();
const uchar16_t* replace = replaceWith.c_str();
const u32 other_size = toReplace.size_raw();
const u32 replace_size = replaceWith.size_raw();
// Determine the delta. The algorithm will change depending on the delta.
s32 delta = replace_size - other_size;
// A character for character replace. The string will not shrink or grow.
if (delta == 0)
{
s32 pos = 0;
while ((pos = find_raw(other, pos)) != -1)
{
for (u32 i = 0; i < replace_size; ++i)
array[pos + i] = replace[i];
++pos;
}
return *this;
}
// We are going to be removing some characters. The string will shrink.
if (delta < 0)
{
u32 i = 0;
for (u32 pos = 0; pos <= used; ++i, ++pos)
{
// Is this potentially a match?
if (array[pos] == *other)
{
// Check to see if we have a match.
u32 j;
for (j = 0; j < other_size; ++j)
{
if (array[pos + j] != other[j])
break;
}
// If we have a match, replace characters.
if (j == other_size)
{
for (j = 0; j < replace_size; ++j)
array[i + j] = replace[j];
i += replace_size - 1;
pos += other_size - 1;
continue;
}
}
// No match found, just copy characters.
array[i - 1] = array[pos];
}
array[i] = 0;
used = i;
return *this;
}
// We are going to be adding characters, so the string size will increase.
// Count the number of times toReplace exists in the string so we can allocate the new size.
u32 find_count = 0;
s32 pos = 0;
while ((pos = find_raw(other, pos)) != -1)
{
++find_count;
++pos;
}
// Re-allocate the string now, if needed.
u32 len = delta * find_count;
if (used + len >= allocated)
reallocate(used + len);
// Start replacing.
pos = 0;
while ((pos = find_raw(other, pos)) != -1)
{
uchar16_t* start = array + pos + other_size - 1;
uchar16_t* ptr = array + used;
uchar16_t* end = array + used + delta;
// Shift characters to make room for the string.
while (ptr != start)
{
*end = *ptr;
--ptr;
--end;
}
// Add the new string now.
for (u32 i = 0; i < replace_size; ++i)
array[pos + i] = replace[i];
pos += replace_size;
used += delta;
}
// Terminate the string and return ourself.
array[used] = 0;
return *this;
}
//! Removes characters from a ustring16..
//! \param c The character to remove.
//! \return A reference to our current string.
ustring16<TAlloc>& remove(uchar32_t c)
{
u32 pos = 0;
u32 found = 0;
u32 len = (c > 0xFFFF ? 2 : 1); // Remove characters equal to the size of c as a UTF-16 character.
for (u32 i=0; i<=used; ++i)
{
uchar32_t uc32 = 0;
if (!UTF16_IS_SURROGATE_HI(array[i]))
uc32 |= array[i];
else if (i + 1 <= used)
{
// Convert the surrogate pair into a single UTF-32 character.
uc32 = unicode::toUTF32(array[i], array[i + 1]);
}
u32 len2 = (uc32 > 0xFFFF ? 2 : 1);
if (uc32 == c)
{
found += len;
continue;
}
array[pos++] = array[i];
if (len2 == 2)
array[pos++] = array[++i];
}
used -= found;
array[used] = 0;
return *this;
}
//! Removes a ustring16 from the ustring16.
//! \param toRemove The string to remove.
//! \return A reference to our current string.
ustring16<TAlloc>& remove(const ustring16<TAlloc>& toRemove)
{
u32 size = toRemove.size_raw();
if (size == 0) return *this;
const uchar16_t* tra = toRemove.c_str();
u32 pos = 0;
u32 found = 0;
for (u32 i=0; i<=used; ++i)
{
u32 j = 0;
while (j < size)
{
if (array[i + j] != tra[j])
break;
++j;
}
if (j == size)
{
found += size;
i += size - 1;
continue;
}
array[pos++] = array[i];
}
used -= found;
array[used] = 0;
return *this;
}
//! Removes characters from the ustring16.
//! \param characters The characters to remove.
//! \return A reference to our current string.
ustring16<TAlloc>& removeChars(const ustring16<TAlloc>& characters)
{
if (characters.size_raw() == 0)
return *this;
u32 pos = 0;
u32 found = 0;
const_iterator iter(characters);
for (u32 i=0; i<=used; ++i)
{
uchar32_t uc32 = 0;
if (!UTF16_IS_SURROGATE_HI(array[i]))
uc32 |= array[i];
else if (i + 1 <= used)
{
// Convert the surrogate pair into a single UTF-32 character.
uc32 = unicode::toUTF32(array[i], array[i+1]);
}
u32 len2 = (uc32 > 0xFFFF ? 2 : 1);
bool cont = false;
iter.toStart();
while (!iter.atEnd())
{
uchar32_t c = *iter;
if (uc32 == c)
{
found += (c > 0xFFFF ? 2 : 1); // Remove characters equal to the size of c as a UTF-16 character.
++i;
cont = true;
break;
}
++iter;
}
if (cont) continue;
array[pos++] = array[i];
if (len2 == 2)
array[pos++] = array[++i];
}
used -= found;
array[used] = 0;
return *this;
}
//! Trims the ustring16.
//! Removes the specified characters (by default, Latin-1 whitespace) from the begining and the end of the ustring16.
//! \param whitespace The characters that are to be considered as whitespace.
//! \return A reference to our current string.
ustring16<TAlloc>& trim(const ustring16<TAlloc>& whitespace = " \t\n\r")
{
core::array<uchar32_t> utf32white = whitespace.toUTF32();
// find start and end of the substring without the specified characters
const s32 begin = findFirstCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
if (begin == -1)
return (*this="");
const s32 end = findLastCharNotInList(utf32white.const_pointer(), whitespace.used + 1);
return (*this = subString(begin, (end +1) - begin));
}
//! Erases a character from the ustring16.
//! May be slow, because all elements following after the erased element have to be copied.
//! \param index Index of element to be erased.
//! \return A reference to our current string.
ustring16<TAlloc>& erase(u32 index)
{
_IRR_DEBUG_BREAK_IF(index>used) // access violation
iterator i(*this, index);
uchar32_t t = *i;
u32 len = (t > 0xFFFF ? 2 : 1);
for (u32 j = static_cast<u32>(i.getPos()) + len; j <= used; ++j)
array[j - len] = array[j];
used -= len;
array[used] = 0;
return *this;
}
//! Validate the existing ustring16, checking for valid surrogate pairs and checking for proper termination.
//! \return A reference to our current string.
ustring16<TAlloc>& validate()
{
// Validate all unicode characters.
for (u32 i=0; i<allocated; ++i)
{
// Terminate on existing null.
if (array[i] == 0)
{
used = i;
return *this;
}
if (UTF16_IS_SURROGATE(array[i]))
{
if (((i+1) >= allocated) || UTF16_IS_SURROGATE_LO(array[i]))
array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
else if (UTF16_IS_SURROGATE_HI(array[i]) && !UTF16_IS_SURROGATE_LO(array[i+1]))
array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
++i;
}
if (array[i] >= 0xFDD0 && array[i] <= 0xFDEF)
array[i] = unicode::UTF_REPLACEMENT_CHARACTER;
}
// terminate
used = 0;
if (allocated > 0)
{
used = allocated - 1;
array[used] = 0;
}
return *this;
}
//! Gets the last char of the ustring16, or 0.
//! \return The last char of the ustring16, or 0.
uchar32_t lastChar() const
{
if (used < 1)
return 0;
if (UTF16_IS_SURROGATE_LO(array[used-1]))
{
// Make sure we have a paired surrogate.
if (used < 2)
return 0;
// Check for an invalid surrogate.
if (!UTF16_IS_SURROGATE_HI(array[used-2]))
return 0;
// Convert the surrogate pair into a single UTF-32 character.
return unicode::toUTF32(array[used-2], array[used-1]);
}
else
{
return array[used-1];
}
}
//! Split the ustring16 into parts.
/** This method will split a ustring16 at certain delimiter characters
into the container passed in as reference. The type of the container
has to be given as template parameter. It must provide a push_back and
a size method.
\param ret The result container
\param c C-style ustring16 of delimiter characters
\param count Number of delimiter characters
\param ignoreEmptyTokens Flag to avoid empty substrings in the result
container. If two delimiters occur without a character in between, an
empty substring would be placed in the result. If this flag is set,
only non-empty strings are stored.
\param keepSeparators Flag which allows to add the separator to the
result ustring16. If this flag is true, the concatenation of the
substrings results in the original ustring16. Otherwise, only the
characters between the delimiters are returned.
\return The number of resulting substrings
*/
template<class container>
u32 split(container& ret, const uchar32_t* const c, u32 count=1, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
{
if (!c)
return 0;
const_iterator i(*this);
const u32 oldSize=ret.size();
u32 pos = 0;
u32 lastpos = 0;
u32 lastpospos = 0;
bool lastWasSeparator = false;
while (!i.atEnd())
{
uchar32_t ch = *i;
bool foundSeparator = false;
for (u32 j=0; j<count; ++j)
{
if (ch == c[j])
{
if ((!ignoreEmptyTokens || pos - lastpos != 0) &&
!lastWasSeparator)
ret.push_back(ustring16<TAlloc>(&array[lastpospos], pos - lastpos));
foundSeparator = true;
lastpos = (keepSeparators ? pos : pos + 1);
lastpospos = (keepSeparators ? i.getPos() : i.getPos() + 1);
break;
}
}
lastWasSeparator = foundSeparator;
++pos;
++i;
}
u32 s = size() + 1;
if (s > lastpos)
ret.push_back(ustring16<TAlloc>(&array[lastpospos], s - lastpos));
return ret.size()-oldSize;
}
//! Split the ustring16 into parts.
/** This method will split a ustring16 at certain delimiter characters
into the container passed in as reference. The type of the container
has to be given as template parameter. It must provide a push_back and
a size method.
\param ret The result container
\param c A unicode string of delimiter characters
\param ignoreEmptyTokens Flag to avoid empty substrings in the result
container. If two delimiters occur without a character in between, an
empty substring would be placed in the result. If this flag is set,
only non-empty strings are stored.
\param keepSeparators Flag which allows to add the separator to the
result ustring16. If this flag is true, the concatenation of the
substrings results in the original ustring16. Otherwise, only the
characters between the delimiters are returned.
\return The number of resulting substrings
*/
template<class container>
u32 split(container& ret, const ustring16<TAlloc>& c, bool ignoreEmptyTokens=true, bool keepSeparators=false) const
{
core::array<uchar32_t> v = c.toUTF32();
return split(ret, v.pointer(), v.size(), ignoreEmptyTokens, keepSeparators);
}
//! Gets the size of the allocated memory buffer for the string.
//! \return The size of the allocated memory buffer.
u32 capacity() const
{
return allocated;
}
//! Returns the raw number of UTF-16 code points in the string which includes the individual surrogates.
//! \return The raw number of UTF-16 code points, excluding the trialing NUL.
u32 size_raw() const
{
return used;
}
//! Inserts a character into the string.
//! \param c The character to insert.
//! \param pos The position to insert the character.
//! \return A reference to our current string.
ustring16<TAlloc>& insert(uchar32_t c, u32 pos)
{
u8 len = (c > 0xFFFF ? 2 : 1);
if (used + len >= allocated)
reallocate(used + len);
used += len;
iterator iter(*this, pos);
for (u32 i = used - 2; i > iter.getPos(); --i)
array[i] = array[i - len];
if (c > 0xFFFF)
{
// c will be multibyte, so split it up into a surrogate pair.
uchar16_t x = static_cast<uchar16_t>(c);
uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
array[iter.getPos()] = vh;
array[iter.getPos()+1] = vl;
}
else
{
array[iter.getPos()] = static_cast<uchar16_t>(c);
}
array[used] = 0;
return *this;
}
//! Inserts a string into the string.
//! \param c The string to insert.
//! \param pos The position to insert the string.
//! \return A reference to our current string.
ustring16<TAlloc>& insert(const ustring16<TAlloc>& c, u32 pos)
{
u32 len = c.size_raw();
if (len == 0) return *this;
if (used + len >= allocated)
reallocate(used + len);
used += len;
iterator iter(*this, pos);
for (u32 i = used - 2; i > iter.getPos() + len; --i)
array[i] = array[i - len];
const uchar16_t* s = c.c_str();
for (u32 i = 0; i < len; ++i)
{
array[pos++] = *s;
++s;
}
array[used] = 0;
return *this;
}
//! Inserts a character into the string.
//! \param c The character to insert.
//! \param pos The position to insert the character.
//! \return A reference to our current string.
ustring16<TAlloc>& insert_raw(uchar16_t c, u32 pos)
{
if (used + 1 >= allocated)
reallocate(used + 1);
++used;
for (u32 i = used - 1; i > pos; --i)
array[i] = array[i - 1];
array[pos] = c;
array[used] = 0;
return *this;
}
//! Removes a character from string.
//! \param pos Position of the character to remove.
//! \return A reference to our current string.
ustring16<TAlloc>& erase_raw(u32 pos)
{
for (u32 i=pos; i<=used; ++i)
{
array[i] = array[i + 1];
}
--used;
array[used] = 0;
return *this;
}
//! Replaces a character in the string.
//! \param c The new character.
//! \param pos The position of the character to replace.
//! \return A reference to our current string.
ustring16<TAlloc>& replace_raw(uchar16_t c, u32 pos)
{
array[pos] = c;
return *this;
}
//! Returns an iterator to the beginning of the string.
//! \return An iterator to the beginning of the string.
iterator begin()
{
iterator i(*this, 0);
return i;
}
//! Returns an iterator to the beginning of the string.
//! \return An iterator to the beginning of the string.
const_iterator begin() const
{
const_iterator i(*this, 0);
return i;
}
//! Returns an iterator to the beginning of the string.
//! \return An iterator to the beginning of the string.
const_iterator cbegin() const
{
const_iterator i(*this, 0);
return i;
}
//! Returns an iterator to the end of the string.
//! \return An iterator to the end of the string.
iterator end()
{
iterator i(*this, 0);
i.toEnd();
return i;
}
//! Returns an iterator to the end of the string.
//! \return An iterator to the end of the string.
const_iterator end() const
{
const_iterator i(*this, 0);
i.toEnd();
return i;
}
//! Returns an iterator to the end of the string.
//! \return An iterator to the end of the string.
const_iterator cend() const
{
const_iterator i(*this, 0);
i.toEnd();
return i;
}
//! Converts the string to a UTF-8 encoded string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return A string containing the UTF-8 encoded string.
core::string<uchar8_t> toUTF8_s(const bool addBOM = false) const
{
core::string<uchar8_t> ret;
ret.reserve(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
const_iterator iter(*this, 0);
// Add the byte order mark if the user wants it.
if (addBOM)
{
ret.append(unicode::BOM_ENCODE_UTF8[0]);
ret.append(unicode::BOM_ENCODE_UTF8[1]);
ret.append(unicode::BOM_ENCODE_UTF8[2]);
}
while (!iter.atEnd())
{
uchar32_t c = *iter;
if (c > 0xFFFF)
{ // 4 bytes
uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
ret.append(b1);
ret.append(b2);
ret.append(b3);
ret.append(b4);
}
else if (c > 0x7FF)
{ // 3 bytes
uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
ret.append(b1);
ret.append(b2);
ret.append(b3);
}
else if (c > 0x7F)
{ // 2 bytes
uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
ret.append(b1);
ret.append(b2);
}
else
{ // 1 byte
ret.append(static_cast<uchar8_t>(c));
}
++iter;
}
return ret;
}
//! Converts the string to a UTF-8 encoded string array.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return An array containing the UTF-8 encoded string.
core::array<uchar8_t> toUTF8(const bool addBOM = false) const
{
core::array<uchar8_t> ret(used * 4 + (addBOM ? unicode::BOM_UTF8_LEN : 0) + 1);
const_iterator iter(*this, 0);
// Add the byte order mark if the user wants it.
if (addBOM)
{
ret.push_back(unicode::BOM_ENCODE_UTF8[0]);
ret.push_back(unicode::BOM_ENCODE_UTF8[1]);
ret.push_back(unicode::BOM_ENCODE_UTF8[2]);
}
while (!iter.atEnd())
{
uchar32_t c = *iter;
if (c > 0xFFFF)
{ // 4 bytes
uchar8_t b1 = (0x1E << 3) | ((c >> 18) & 0x7);
uchar8_t b2 = (0x2 << 6) | ((c >> 12) & 0x3F);
uchar8_t b3 = (0x2 << 6) | ((c >> 6) & 0x3F);
uchar8_t b4 = (0x2 << 6) | (c & 0x3F);
ret.push_back(b1);
ret.push_back(b2);
ret.push_back(b3);
ret.push_back(b4);
}
else if (c > 0x7FF)
{ // 3 bytes
uchar8_t b1 = (0xE << 4) | ((c >> 12) & 0xF);
uchar8_t b2 = (0x2 << 6) | ((c >> 6) & 0x3F);
uchar8_t b3 = (0x2 << 6) | (c & 0x3F);
ret.push_back(b1);
ret.push_back(b2);
ret.push_back(b3);
}
else if (c > 0x7F)
{ // 2 bytes
uchar8_t b1 = (0x6 << 5) | ((c >> 6) & 0x1F);
uchar8_t b2 = (0x2 << 6) | (c & 0x3F);
ret.push_back(b1);
ret.push_back(b2);
}
else
{ // 1 byte
ret.push_back(static_cast<uchar8_t>(c));
}
++iter;
}
ret.push_back(0);
return ret;
}
#ifdef USTRING_CPP0X_NEWLITERALS // C++0x
//! Converts the string to a UTF-16 encoded string.
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return A string containing the UTF-16 encoded string.
core::string<char16_t> toUTF16_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
core::string<char16_t> ret;
ret.reserve(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
// Add the BOM if specified.
if (addBOM)
{
if (endian == unicode::EUTFEE_NATIVE)
ret[0] = unicode::BOM;
else if (endian == unicode::EUTFEE_LITTLE)
{
uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
*ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
*ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
}
else
{
uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ret.c_str());
*ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
*ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
}
}
ret.append(array);
if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
{
char16_t* ptr = ret.c_str();
for (u32 i = 0; i < ret.size(); ++i)
*ptr++ = unicode::swapEndian16(*ptr);
}
return ret;
}
#endif
//! Converts the string to a UTF-16 encoded string array.
//! Unfortunately, no toUTF16_s() version exists due to limitations with Irrlicht's string class.
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return An array containing the UTF-16 encoded string.
core::array<uchar16_t> toUTF16(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
core::array<uchar16_t> ret(used + (addBOM ? unicode::BOM_UTF16_LEN : 0) + 1);
uchar16_t* ptr = ret.pointer();
// Add the BOM if specified.
if (addBOM)
{
if (endian == unicode::EUTFEE_NATIVE)
*ptr = unicode::BOM;
else if (endian == unicode::EUTFEE_LITTLE)
{
uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
*ptr8++ = unicode::BOM_ENCODE_UTF16_LE[0];
*ptr8 = unicode::BOM_ENCODE_UTF16_LE[1];
}
else
{
uchar8_t* ptr8 = reinterpret_cast<uchar8_t*>(ptr);
*ptr8++ = unicode::BOM_ENCODE_UTF16_BE[0];
*ptr8 = unicode::BOM_ENCODE_UTF16_BE[1];
}
++ptr;
}
memcpy((void*)ptr, (void*)array, used * sizeof(uchar16_t));
if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
{
for (u32 i = 0; i <= used; ++i)
ptr[i] = unicode::swapEndian16(ptr[i]);
}
ret.set_used(used + (addBOM ? unicode::BOM_UTF16_LEN : 0));
ret.push_back(0);
return ret;
}
#ifdef USTRING_CPP0X_NEWLITERALS // C++0x
//! Converts the string to a UTF-32 encoded string.
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return A string containing the UTF-32 encoded string.
core::string<char32_t> toUTF32_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
core::string<char32_t> ret;
ret.reserve(size() + 1 + (addBOM ? unicode::BOM_UTF32_LEN : 0));
const_iterator iter(*this, 0);
// Add the BOM if specified.
if (addBOM)
{
if (endian == unicode::EUTFEE_NATIVE)
ret.append(unicode::BOM);
else
{
union
{
uchar32_t full;
u8 chunk[4];
} t;
if (endian == unicode::EUTFEE_LITTLE)
{
t.chunk[0] = unicode::BOM_ENCODE_UTF32_LE[0];
t.chunk[1] = unicode::BOM_ENCODE_UTF32_LE[1];
t.chunk[2] = unicode::BOM_ENCODE_UTF32_LE[2];
t.chunk[3] = unicode::BOM_ENCODE_UTF32_LE[3];
}
else
{
t.chunk[0] = unicode::BOM_ENCODE_UTF32_BE[0];
t.chunk[1] = unicode::BOM_ENCODE_UTF32_BE[1];
t.chunk[2] = unicode::BOM_ENCODE_UTF32_BE[2];
t.chunk[3] = unicode::BOM_ENCODE_UTF32_BE[3];
}
ret.append(t.full);
}
}
while (!iter.atEnd())
{
uchar32_t c = *iter;
if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
c = unicode::swapEndian32(c);
ret.append(c);
++iter;
}
return ret;
}
#endif
//! Converts the string to a UTF-32 encoded string array.
//! Unfortunately, no toUTF32_s() version exists due to limitations with Irrlicht's string class.
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return An array containing the UTF-32 encoded string.
core::array<uchar32_t> toUTF32(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
core::array<uchar32_t> ret(size() + (addBOM ? unicode::BOM_UTF32_LEN : 0) + 1);
const_iterator iter(*this, 0);
// Add the BOM if specified.
if (addBOM)
{
if (endian == unicode::EUTFEE_NATIVE)
ret.push_back(unicode::BOM);
else
{
union
{
uchar32_t full;
u8 chunk[4];
} t;
if (endian == unicode::EUTFEE_LITTLE)
{
t.chunk[0] = unicode::BOM_ENCODE_UTF32_LE[0];
t.chunk[1] = unicode::BOM_ENCODE_UTF32_LE[1];
t.chunk[2] = unicode::BOM_ENCODE_UTF32_LE[2];
t.chunk[3] = unicode::BOM_ENCODE_UTF32_LE[3];
}
else
{
t.chunk[0] = unicode::BOM_ENCODE_UTF32_BE[0];
t.chunk[1] = unicode::BOM_ENCODE_UTF32_BE[1];
t.chunk[2] = unicode::BOM_ENCODE_UTF32_BE[2];
t.chunk[3] = unicode::BOM_ENCODE_UTF32_BE[3];
}
ret.push_back(t.full);
}
}
ret.push_back(0);
while (!iter.atEnd())
{
uchar32_t c = *iter;
if (endian != unicode::EUTFEE_NATIVE && getEndianness() != endian)
c = unicode::swapEndian32(c);
ret.push_back(c);
++iter;
}
return ret;
}
//! Converts the string to a wchar_t encoded string.
/** The size of a wchar_t changes depending on the platform. This function will store a
correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t. **/
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return A string containing the wchar_t encoded string.
core::string<wchar_t> toWCHAR_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
if (sizeof(wchar_t) == 4)
{
core::array<uchar32_t> a(toUTF32(endian, addBOM));
core::stringw ret(a.pointer());
return ret;
}
else if (sizeof(wchar_t) == 2)
{
if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
{
core::stringw ret(array);
return ret;
}
else
{
core::array<uchar16_t> a(toUTF16(endian, addBOM));
core::stringw ret(a.pointer());
return ret;
}
}
else if (sizeof(wchar_t) == 1)
{
core::array<uchar8_t> a(toUTF8(addBOM));
core::stringw ret(a.pointer());
return ret;
}
// Shouldn't happen.
return core::stringw();
}
//! Converts the string to a wchar_t encoded string array.
/** The size of a wchar_t changes depending on the platform. This function will store a
correct UTF-8, -16, or -32 encoded string depending on the size of a wchar_t. **/
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return An array containing the wchar_t encoded string.
core::array<wchar_t> toWCHAR(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
if (sizeof(wchar_t) == 4)
{
core::array<uchar32_t> a(toUTF32(endian, addBOM));
core::array<wchar_t> ret(a.size());
ret.set_used(a.size());
memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar32_t));
return ret;
}
if (sizeof(wchar_t) == 2)
{
if (endian == unicode::EUTFEE_NATIVE && addBOM == false)
{
core::array<wchar_t> ret(used);
ret.set_used(used);
memcpy((void*)ret.pointer(), (void*)array, used * sizeof(uchar16_t));
return ret;
}
else
{
core::array<uchar16_t> a(toUTF16(endian, addBOM));
core::array<wchar_t> ret(a.size());
ret.set_used(a.size());
memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar16_t));
return ret;
}
}
if (sizeof(wchar_t) == 1)
{
core::array<uchar8_t> a(toUTF8(addBOM));
core::array<wchar_t> ret(a.size());
ret.set_used(a.size());
memcpy((void*)ret.pointer(), (void*)a.pointer(), a.size() * sizeof(uchar8_t));
return ret;
}
// Shouldn't happen.
return core::array<wchar_t>();
}
//! Converts the string to a properly encoded io::path string.
//! \param endian The desired endianness of the string.
//! \param addBOM If true, the proper unicode byte-order mark will be prefixed to the string.
//! \return An io::path string containing the properly encoded string.
io::path toPATH_s(const unicode::EUTF_ENDIAN endian = unicode::EUTFEE_NATIVE, const bool addBOM = false) const
{
#if defined(_IRR_WCHAR_FILESYSTEM)
return toWCHAR_s(endian, addBOM);
#else
return toUTF8_s(addBOM);
#endif
}
//! Loads an unknown stream of data.
//! Will attempt to determine if the stream is unicode data. Useful for loading from files.
//! \param data The data stream to load from.
//! \param data_size The length of the data string.
//! \return A reference to our current string.
ustring16<TAlloc>& loadDataStream(const char* data, size_t data_size)
{
// Clear our string.
*this = "";
if (!data)
return *this;
unicode::EUTF_ENCODE e = unicode::determineUnicodeBOM(data);
switch (e)
{
default:
case unicode::EUTFE_UTF8:
append((uchar8_t*)data, data_size);
break;
case unicode::EUTFE_UTF16:
case unicode::EUTFE_UTF16_BE:
case unicode::EUTFE_UTF16_LE:
append((uchar16_t*)data, data_size / 2);
break;
case unicode::EUTFE_UTF32:
case unicode::EUTFE_UTF32_BE:
case unicode::EUTFE_UTF32_LE:
append((uchar32_t*)data, data_size / 4);
break;
}
return *this;
}
//! Gets the encoding of the Unicode string this class contains.
//! \return An enum describing the current encoding of this string.
const unicode::EUTF_ENCODE getEncoding() const
{
return encoding;
}
//! Gets the endianness of the Unicode string this class contains.
//! \return An enum describing the endianness of this string.
const unicode::EUTF_ENDIAN getEndianness() const
{
if (encoding == unicode::EUTFE_UTF16_LE ||
encoding == unicode::EUTFE_UTF32_LE)
return unicode::EUTFEE_LITTLE;
else return unicode::EUTFEE_BIG;
}
private:
//! Reallocate the string, making it bigger or smaller.
//! \param new_size The new size of the string.
void reallocate(u32 new_size)
{
uchar16_t* old_array = array;
array = allocator.allocate(new_size + 1); //new u16[new_size];
allocated = new_size + 1;
if (old_array == 0) return;
u32 amount = used < new_size ? used : new_size;
for (u32 i=0; i<=amount; ++i)
array[i] = old_array[i];
if (allocated <= used)
used = allocated - 1;
array[used] = 0;
allocator.deallocate(old_array); // delete [] old_array;
}
//--- member variables
uchar16_t* array;
unicode::EUTF_ENCODE encoding;
u32 allocated;
u32 used;
TAlloc allocator;
//irrAllocator<uchar16_t> allocator;
};
typedef ustring16<irrAllocator<uchar16_t> > ustring;
//! Appends two ustring16s.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a null-terminated unicode string.
template <typename TAlloc, class B>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const B* const right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a null-terminated unicode string.
template <class B, typename TAlloc>
inline ustring16<TAlloc> operator+(const B* const left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and an Irrlicht string.
template <typename TAlloc, typename B, typename BAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const string<B, BAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and an Irrlicht string.
template <typename TAlloc, typename B, typename BAlloc>
inline ustring16<TAlloc> operator+(const string<B, BAlloc>& left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a std::basic_string.
template <typename TAlloc, typename B, typename A, typename BAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const std::basic_string<B, A, BAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a std::basic_string.
template <typename TAlloc, typename B, typename A, typename BAlloc>
inline ustring16<TAlloc> operator+(const std::basic_string<B, A, BAlloc>& left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a char.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const char right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a char.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const char left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
#ifdef USTRING_CPP0X_NEWLITERALS
//! Appends a ustring16 and a uchar32_t.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const uchar32_t right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
//! Appends a ustring16 and a uchar32_t.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const uchar32_t left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret(left);
ret += right;
return ret;
}
#endif
//! Appends a ustring16 and a short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const short right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and a short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const short left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and an unsigned short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned short right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and an unsigned short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned short left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and an int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const int right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and an int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const int left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and an unsigned int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned int right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and an unsigned int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned int left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and a long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const long right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and a long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const long left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and an unsigned long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const unsigned long right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and an unsigned long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned long left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and a float.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const float right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and a float.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const float left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
//! Appends a ustring16 and a double.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const ustring16<TAlloc>& left, const double right)
{
ustring16<TAlloc> ret(left);
ret += core::stringc(right);
return ret;
}
//! Appends a ustring16 and a double.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const double left, const ustring16<TAlloc>& right)
{
ustring16<TAlloc> ret((core::stringc(left)));
ret += right;
return ret;
}
#ifdef USTRING_CPP0X
//! Appends two ustring16s.
template <typename TAlloc>
inline ustring16<TAlloc>&& operator+(const ustring16<TAlloc>& left, ustring16<TAlloc>&& right)
{
//std::cout << "MOVE operator+(&, &&)" << std::endl;
right.insert(left, 0);
return std::move(right);
}
//! Appends two ustring16s.
template <typename TAlloc>
inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const ustring16<TAlloc>& right)
{
//std::cout << "MOVE operator+(&&, &)" << std::endl;
left.append(right);
return std::move(left);
}
//! Appends two ustring16s.
template <typename TAlloc>
inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, ustring16<TAlloc>&& right)
{
//std::cout << "MOVE operator+(&&, &&)" << std::endl;
if ((right.size_raw() <= left.capacity() - left.size_raw()) ||
(right.capacity() - right.size_raw() < left.size_raw()))
{
left.append(right);
return std::move(left);
}
else
{
right.insert(left, 0);
return std::move(right);
}
}
//! Appends a ustring16 and a null-terminated unicode string.
template <typename TAlloc, class B>
inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const B* const right)
{
//std::cout << "MOVE operator+(&&, B*)" << std::endl;
left.append(right);
return std::move(left);
}
//! Appends a ustring16 and a null-terminated unicode string.
template <class B, typename TAlloc>
inline ustring16<TAlloc>&& operator+(const B* const left, ustring16<TAlloc>&& right)
{
//std::cout << "MOVE operator+(B*, &&)" << std::endl;
right.insert(left, 0);
return std::move(right);
}
//! Appends a ustring16 and an Irrlicht string.
template <typename TAlloc, typename B, typename BAlloc>
inline ustring16<TAlloc>&& operator+(const string<B, BAlloc>& left, ustring16<TAlloc>&& right)
{
//std::cout << "MOVE operator+(&, &&)" << std::endl;
right.insert(left, 0);
return std::move(right);
}
//! Appends a ustring16 and an Irrlicht string.
template <typename TAlloc, typename B, typename BAlloc>
inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const string<B, BAlloc>& right)
{
//std::cout << "MOVE operator+(&&, &)" << std::endl;
left.append(right);
return std::move(left);
}
//! Appends a ustring16 and a std::basic_string.
template <typename TAlloc, typename B, typename A, typename BAlloc>
inline ustring16<TAlloc>&& operator+(const std::basic_string<B, A, BAlloc>& left, ustring16<TAlloc>&& right)
{
//std::cout << "MOVE operator+(&, &&)" << std::endl;
right.insert(core::ustring16<TAlloc>(left), 0);
return std::move(right);
}
//! Appends a ustring16 and a std::basic_string.
template <typename TAlloc, typename B, typename A, typename BAlloc>
inline ustring16<TAlloc>&& operator+(ustring16<TAlloc>&& left, const std::basic_string<B, A, BAlloc>& right)
{
//std::cout << "MOVE operator+(&&, &)" << std::endl;
left.append(right);
return std::move(left);
}
//! Appends a ustring16 and a char.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const char right)
{
left.append((uchar32_t)right);
return std::move(left);
}
//! Appends a ustring16 and a char.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const char left, ustring16<TAlloc>&& right)
{
right.insert((uchar32_t)left, 0);
return std::move(right);
}
#ifdef USTRING_CPP0X_NEWLITERALS
//! Appends a ustring16 and a uchar32_t.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const uchar32_t right)
{
left.append(right);
return std::move(left);
}
//! Appends a ustring16 and a uchar32_t.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const uchar32_t left, ustring16<TAlloc>&& right)
{
right.insert(left, 0);
return std::move(right);
}
#endif
//! Appends a ustring16 and a short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const short right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and a short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const short left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and an unsigned short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned short right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and an unsigned short.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned short left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and an int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const int right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and an int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const int left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and an unsigned int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned int right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and an unsigned int.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned int left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and a long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const long right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and a long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const long left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and an unsigned long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const unsigned long right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and an unsigned long.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const unsigned long left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and a float.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const float right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and a float.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const float left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
//! Appends a ustring16 and a double.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(ustring16<TAlloc>&& left, const double right)
{
left.append(core::stringc(right));
return std::move(left);
}
//! Appends a ustring16 and a double.
template <typename TAlloc>
inline ustring16<TAlloc> operator+(const double left, ustring16<TAlloc>&& right)
{
right.insert(core::stringc(left), 0);
return std::move(right);
}
#endif
#ifndef USTRING_NO_STL
//! Writes a ustring16 to an ostream.
template <typename TAlloc>
inline std::ostream& operator<<(std::ostream& out, const ustring16<TAlloc>& in)
{
out << in.toUTF8_s().c_str();
return out;
}
//! Writes a ustring16 to a wostream.
template <typename TAlloc>
inline std::wostream& operator<<(std::wostream& out, const ustring16<TAlloc>& in)
{
out << in.toWCHAR_s().c_str();
return out;
}
#endif
#ifndef USTRING_NO_STL
namespace unicode
{
//! Hashing algorithm for hashing a ustring. Used for things like unordered_maps.
//! Algorithm taken from std::hash<std::string>.
class hash : public std::unary_function<core::ustring, size_t>
{
public:
size_t operator()(const core::ustring& s) const
{
size_t ret = 2166136261U;
size_t index = 0;
size_t stride = 1 + s.size_raw() / 10;
core::ustring::const_iterator i = s.begin();
while (i != s.end())
{
// TODO: Don't force u32 on an x64 OS. Make it agnostic.
ret = 16777619U * ret ^ (size_t)s[(u32)index];
index += stride;
i += stride;
}
return (ret);
}
};
} // end namespace unicode
#endif
} // end namespace core
} // end namespace irr
#endif
