|
59
|
1 module typeinfo2.ti_Ag;
|
|
|
2
|
|
|
3 private int string_cmp(char[] s1, char[] s2)
|
|
|
4 {
|
|
|
5 auto len = s1.length;
|
|
|
6 if (s2.length < len)
|
|
|
7 len = s2.length;
|
|
|
8 int result = memcmp(s1.ptr, s2.ptr, len);
|
|
|
9 if (result == 0)
|
|
|
10 result = cast(int)(cast(ptrdiff_t)s1.length - cast(ptrdiff_t)s2.length);
|
|
|
11 return result;
|
|
|
12 }
|
|
|
13
|
|
|
14 extern(C) int memcmp(void*,void*,size_t);
|
|
|
15
|
|
|
16 // byte[]
|
|
|
17
|
|
|
18 class TypeInfo_Ag : TypeInfo
|
|
|
19 {
|
|
|
20 char[] toString() { return "byte[]"; }
|
|
|
21
|
|
|
22 hash_t getHash(void *p)
|
|
|
23 { byte[] s = *cast(byte[]*)p;
|
|
|
24 size_t len = s.length;
|
|
|
25 byte *str = s.ptr;
|
|
|
26 hash_t hash = 0;
|
|
|
27
|
|
|
28 while (1)
|
|
|
29 {
|
|
|
30 switch (len)
|
|
|
31 {
|
|
|
32 case 0:
|
|
|
33 return hash;
|
|
|
34
|
|
|
35 case 1:
|
|
|
36 hash *= 9;
|
|
|
37 hash += *cast(ubyte *)str;
|
|
|
38 return hash;
|
|
|
39
|
|
|
40 case 2:
|
|
|
41 hash *= 9;
|
|
|
42 hash += *cast(ushort *)str;
|
|
|
43 return hash;
|
|
|
44
|
|
|
45 case 3:
|
|
|
46 hash *= 9;
|
|
|
47 hash += (*cast(ushort *)str << 8) +
|
|
|
48 (cast(ubyte *)str)[2];
|
|
|
49 return hash;
|
|
|
50
|
|
|
51 default:
|
|
|
52 hash *= 9;
|
|
|
53 hash += *cast(uint *)str;
|
|
|
54 str += 4;
|
|
|
55 len -= 4;
|
|
|
56 break;
|
|
|
57 }
|
|
|
58 }
|
|
|
59
|
|
|
60 return hash;
|
|
|
61 }
|
|
|
62
|
|
|
63 int equals(void *p1, void *p2)
|
|
|
64 {
|
|
|
65 byte[] s1 = *cast(byte[]*)p1;
|
|
|
66 byte[] s2 = *cast(byte[]*)p2;
|
|
|
67
|
|
|
68 return s1.length == s2.length &&
|
|
|
69 memcmp(cast(byte *)s1, cast(byte *)s2, s1.length) == 0;
|
|
|
70 }
|
|
|
71
|
|
|
72 int compare(void *p1, void *p2)
|
|
|
73 {
|
|
|
74 byte[] s1 = *cast(byte[]*)p1;
|
|
|
75 byte[] s2 = *cast(byte[]*)p2;
|
|
|
76 size_t len = s1.length;
|
|
|
77
|
|
|
78 if (s2.length < len)
|
|
|
79 len = s2.length;
|
|
|
80 for (size_t u = 0; u < len; u++)
|
|
|
81 {
|
|
|
82 int result = s1[u] - s2[u];
|
|
|
83 if (result)
|
|
|
84 return result;
|
|
|
85 }
|
|
|
86 return cast(int)s1.length - cast(int)s2.length;
|
|
|
87 }
|
|
|
88
|
|
|
89 size_t tsize()
|
|
|
90 {
|
|
|
91 return (byte[]).sizeof;
|
|
|
92 }
|
|
|
93
|
|
|
94 uint flags()
|
|
|
95 {
|
|
|
96 return 1;
|
|
|
97 }
|
|
|
98
|
|
|
99 TypeInfo next()
|
|
|
100 {
|
|
|
101 return typeid(byte);
|
|
|
102 }
|
|
|
103 }
|
|
|
104
|
|
|
105
|
|
|
106 // ubyte[]
|
|
|
107
|
|
|
108 class TypeInfo_Ah : TypeInfo_Ag
|
|
|
109 {
|
|
|
110 char[] toString() { return "ubyte[]"; }
|
|
|
111
|
|
|
112 int compare(void *p1, void *p2)
|
|
|
113 {
|
|
|
114 char[] s1 = *cast(char[]*)p1;
|
|
|
115 char[] s2 = *cast(char[]*)p2;
|
|
|
116
|
|
|
117 return string_cmp(s1, s2);
|
|
|
118 }
|
|
|
119
|
|
|
120 TypeInfo next()
|
|
|
121 {
|
|
|
122 return typeid(ubyte);
|
|
|
123 }
|
|
|
124 }
|
|
|
125
|
|
|
126 // void[]
|
|
|
127
|
|
|
128 class TypeInfo_Av : TypeInfo_Ah
|
|
|
129 {
|
|
|
130 char[] toString() { return "void[]"; }
|
|
|
131
|
|
|
132 TypeInfo next()
|
|
|
133 {
|
|
|
134 return typeid(void);
|
|
|
135 }
|
|
|
136 }
|
|
|
137
|
|
|
138 // bool[]
|
|
|
139
|
|
|
140 class TypeInfo_Ab : TypeInfo_Ah
|
|
|
141 {
|
|
|
142 char[] toString() { return "bool[]"; }
|
|
|
143
|
|
|
144 TypeInfo next()
|
|
|
145 {
|
|
|
146 return typeid(bool);
|
|
|
147 }
|
|
|
148 }
|
|
|
149
|
|
|
150 // char[]
|
|
|
151
|
|
|
152 class TypeInfo_Aa : TypeInfo_Ag
|
|
|
153 {
|
|
|
154 char[] toString() { return "char[]"; }
|
|
|
155
|
|
|
156 hash_t getHash(void *p)
|
|
|
157 { char[] s = *cast(char[]*)p;
|
|
|
158 hash_t hash = 0;
|
|
|
159
|
|
|
160 version (all)
|
|
|
161 {
|
|
|
162 foreach (char c; s)
|
|
|
163 hash = hash * 11 + c;
|
|
|
164 }
|
|
|
165 else
|
|
|
166 {
|
|
|
167 size_t len = s.length;
|
|
|
168 char *str = s;
|
|
|
169
|
|
|
170 while (1)
|
|
|
171 {
|
|
|
172 switch (len)
|
|
|
173 {
|
|
|
174 case 0:
|
|
|
175 return hash;
|
|
|
176
|
|
|
177 case 1:
|
|
|
178 hash *= 9;
|
|
|
179 hash += *cast(ubyte *)str;
|
|
|
180 return hash;
|
|
|
181
|
|
|
182 case 2:
|
|
|
183 hash *= 9;
|
|
|
184 hash += *cast(ushort *)str;
|
|
|
185 return hash;
|
|
|
186
|
|
|
187 case 3:
|
|
|
188 hash *= 9;
|
|
|
189 hash += (*cast(ushort *)str << 8) +
|
|
|
190 (cast(ubyte *)str)[2];
|
|
|
191 return hash;
|
|
|
192
|
|
|
193 default:
|
|
|
194 hash *= 9;
|
|
|
195 hash += *cast(uint *)str;
|
|
|
196 str += 4;
|
|
|
197 len -= 4;
|
|
|
198 break;
|
|
|
199 }
|
|
|
200 }
|
|
|
201 }
|
|
|
202 return hash;
|
|
|
203 }
|
|
|
204
|
|
|
205 TypeInfo next()
|
|
|
206 {
|
|
|
207 return typeid(char);
|
|
|
208 }
|
|
|
209 }
|
|
|
210
|
|
|
211
|
