java.nonstandard.SafeUtf source code

1 /**
2  * Stuff for working with narrow strings.
3  * Safe because of strong type checking.
4  *
5  * Authors: Denis Shelomovskij <verylonglogin.reg@gmail.com>
6  */
7 module java.nonstandard.SafeUtf;
8 
9 import java.nonstandard.UtfBase;
10 
11 private const bool UTFTypeCheck = true;
12 mixin(UtfBaseText);
13 
14 unittest {
15     auto s = "abаб回家\U00064321\U00064321d"; assert(s.length == 1+1+2+2+3+3+4+4+1);
16     auto ws = "abаб回家\U00064321\U00064321d"w; assert(ws.length == 1+1+1+1+1+1+2+2+1);
17     auto dchars = "abаб回家\U00064321\U00064321d"d;
18     auto  starts  = [1, 1, 1,0, 1,0, 1,0,0, 1,0,0, 1,0,0,0, 1,0,0,0, 1];
19     auto wstarts  = [1, 1, 1,   1,   1,     1,     1,0,     1,0    , 1];
20     assert(s.length == starts.length);
21     assert(ws.length == wstarts.length);
22 
23     auto  strides = [1, 1, 2, 2, 3, 3, 4, 4, 1];
24     auto wstrides = [1, 1, 1, 1, 1, 1, 2, 2, 1];
25     auto shifts0 = [0, 1, 1+1, 1+1+2, 1+1+2+2, 1+1+2+2+3, 1+1+2+2+3+3, 1+1+2+2+3+3+4, 1+1+2+2+3+3+4+4];
26     assert(strides.length == dchars.length);
27     assert(wstrides.length == dchars.length);
28     assert(shifts0.length == dchars.length);
29 
30     UTF8index prevStart = 0;
31     UCSindex n = 0;
32     foreach(size_t iter, char ch; s) {
33         UTF8index idx = iter;
34         assert(s.isUTF8sequenceStart(idx) == starts[iter]);
35         if (starts[iter]) {
36             s.validateUTF8index(idx);
37             assert(s.UTF8strideAt(idx) == strides[n]);
38             assert(s.toUTF8shift(UTF8index(0), n) == shifts0[n]);
39             assert(s.toUTF8shift( UTF8index(shifts0[n]), -n) == -shifts0[n]);
40             if (iter) assert(s.offsetBefore(idx) == prevStart);
41             assert(s[0 .. val(idx)].UCScount == n);
42             assert(s[val(idx) .. $].UCScount == strides.length - n);
43 
44             UTF8shift di;
45             assert(s.dcharAt(idx, di) == dchars[n]);
46             assert(di == strides[n]);
47             if (iter) assert(s.dcharBefore(idx) == s.dcharAt(prevStart));
48             if (iter) assert(s.dcharAfter(prevStart) == s.dcharAt(idx));
49             auto dcharStr = s[val(idx) .. val(idx) + strides[n]];
50             assert(s.dcharAsStringAt(idx, di) == dcharStr && di == dcharStr.length);
51             assert(dcharToString(s.dcharAt(idx)) == dcharStr);
52             prevStart = idx;
53             ++n;
54         }
55         UTF8index t = idx;
56         s.adjustUTF8index(t);
57         assert(t == prevStart);
58     }
59 
60     n = 0;
61     foreach(UTF16index i, wchar ch; ws)
62         if (wstarts[i]) {
63             //s.validateUTF16index(i);
64             UTF16shift di;
65             assert(ws.dcharAt(i, di) == dchars[n]);
66             assert(di == wstrides[n]);
67             ++n;
68         }
69 
70     s.validateUTF8index( UTF8index(cast(ptrdiff_t)s.length) );
71 }