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