java_bin 0.3.2 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/.gitignore CHANGED
@@ -29,3 +29,4 @@ Makefile
29
29
  *.lib
30
30
  *.pdb
31
31
  *.obj
32
+ *.s
data/CHANGELOG CHANGED
@@ -1,3 +1,8 @@
1
+ 0.3.3 (2010/02/01)
2
+ * fix iterator false bug
3
+ * performance improve
4
+ * refactoring
5
+
1
6
  0.3.2 (2010/01/25)
2
7
  * windows 1.9.x build
3
8
  * fix pure parser bug
data/README.rdoc CHANGED
@@ -6,37 +6,22 @@ This is an Apache Solr JavaBin format (binary format) implementation for Ruby.
6
6
 
7
7
  * fast parse(2.5 - 5 times faster than ruby eval), and less network traffic.
8
8
  MRI 1.8.7
9
- [data1]
10
- ruby eval parse. 5000 times. elapsed time 1.282744
11
- javabin parse. 5000 times. elapsed time 0.4634
12
- 2.76811394044022 times
13
-
14
- [data2]
15
- ruby2 eval parse. 5000 times. elapsed time 6.568942
16
- javabin2 parse. 5000 times. elapsed time 2.267351
17
- 2.89718795193157 times
9
+ [data2]
10
+ ruby eval parse. 5000 times. elapsed time 6.664981
11
+ javabin parse. 5000 times. elapsed time 1.472825
12
+ 4.52530409247534 times
18
13
 
19
14
  REE 1.8.7
20
- [data1]
21
- ruby eval parse. 5000 times. elapsed time 0.940934
22
- javabin parse. 5000 times. elapsed time 0.310581
23
- 3.02959292422911 times
24
-
25
15
  [data2]
26
- ruby2 eval parse. 5000 times. elapsed time 4.708985
27
- javabin2 parse. 5000 times. elapsed time 1.482276
28
- 3.176861124379 times
29
-
30
- YARV 1.9.2
31
- [data1]
32
- ruby eval parse. 5000 times. elapsed time 1.348342119
33
- javabin parse. 5000 times. elapsed time 0.367371147
34
- 3.6702450097421506 times
16
+ ruby eval parse. 5000 times. elapsed time 4.844482
17
+ javabin parse. 5000 times. elapsed time 1.059044
18
+ 4.57439162112245 times
35
19
 
20
+ YARV 1.9.2 pre1
36
21
  [data2]
37
- ruby2 eval parse. 5000 times. elapsed time 6.486995777
38
- javabin2 parse. 5000 times. elapsed time 1.73077786
39
- 3.748023317677521 times
22
+ ruby eval parse. 5000 times. elapsed time 6.659331328
23
+ javabin parse. 5000 times. elapsed time 1.261828473
24
+ 5.277525012704322 times
40
25
 
41
26
  * rsolr/solr-ruby support.
42
27
  * pure and c extension code.
data/VERSION CHANGED
@@ -1 +1 @@
1
- 0.3.2
1
+ 0.3.3
@@ -9,40 +9,57 @@ static VALUE rb_cParser;
9
9
 
10
10
  static ID i_At; // Time#at用
11
11
  #ifdef HAVE_RUBY_ENCODING_H
12
- static rb_encoding* rb_encUtf8;
12
+ static rb_encoding* rb_encUtf8;
13
13
  #endif
14
14
 
15
+ static VALUE jbp_numFound;
16
+ static VALUE jbp_start;
17
+ static VALUE jbp_maxScore;
18
+ static VALUE jbp_docs;
19
+
20
+ static VALUE jbp_terminator;
21
+
15
22
  /*
16
23
  * javabinフォーマット読み込み関数群
17
24
  */
25
+ static inline void JavaBinParser_extend_cache(JAVA_BIN_PARSER* ptr) {
26
+ int next_size;
18
27
 
19
- static int32_t JavaBinParser_read_v_int(JAVA_BIN_PARSER* ptr) {
28
+ next_size = ((ptr->cache == NULL) ? 64 : ptr->cache_size * 2);
29
+ ptr->cache = (VALUE*) realloc(ptr->cache, next_size * sizeof(VALUE));
30
+ if (!ptr->cache) {
31
+ rb_raise(rb_eRuntimeError, "JavaBinParser_extend_cache - allocate error");
32
+ }
33
+ ptr->cache_size = next_size;
34
+ }
35
+
36
+ static inline int32_t JavaBinParser_read_v_int(JAVA_BIN_PARSER* ptr) {
20
37
  unsigned char byte;
21
38
  int32_t result;
22
39
  int shift;
23
40
  byte = _getbyte(ptr);
24
41
  result = byte & 0x7f;
25
- for(shift = 7; (byte & 0x80) != 0; shift += 7) {
42
+ for (shift = 7; (byte & 0x80) != 0; shift += 7) {
26
43
  byte = _getbyte(ptr);
27
44
  result |= (((int32_t)(byte & 0x7f)) << shift);
28
45
  }
29
46
  return result;
30
47
  }
31
48
 
32
- static int64_t JavaBinParser_read_v_long(JAVA_BIN_PARSER* ptr) {
49
+ static inline int64_t JavaBinParser_read_v_long(JAVA_BIN_PARSER* ptr) {
33
50
  unsigned char byte;
34
51
  int64_t result;
35
52
  int shift;
36
53
  byte = _getbyte(ptr);
37
54
  result = byte & 0x7f;
38
- for(shift = 7; (byte & 0x80) != 0; shift += 7) {
55
+ for (shift = 7; (byte & 0x80) != 0; shift += 7) {
39
56
  byte = _getbyte(ptr);
40
57
  result |= (((int64_t)(byte & 0x7f)) << shift);
41
58
  }
42
59
  return result;
43
60
  }
44
61
 
45
- static int JavaBinParser_read_size(JAVA_BIN_PARSER* ptr) {
62
+ static inline int JavaBinParser_read_size(JAVA_BIN_PARSER* ptr) {
46
63
  int size;
47
64
  size = (ptr->tag_byte & 0x1f);
48
65
  if (size == 0x1f) {
@@ -51,7 +68,7 @@ static int JavaBinParser_read_size(JAVA_BIN_PARSER* ptr) {
51
68
  return size;
52
69
  }
53
70
 
54
- static VALUE JavaBinParser_read_small_int(JAVA_BIN_PARSER* ptr) {
71
+ static inline VALUE JavaBinParser_read_small_int(JAVA_BIN_PARSER* ptr) {
55
72
  int32_t result;
56
73
  result = ptr->tag_byte & 0x0f;
57
74
  if ((ptr->tag_byte & 0x10) != 0) {
@@ -60,7 +77,7 @@ static VALUE JavaBinParser_read_small_int(JAVA_BIN_PARSER* ptr) {
60
77
  return INT2NUM(result);
61
78
  }
62
79
 
63
- static VALUE JavaBinParser_read_small_long(JAVA_BIN_PARSER* ptr) {
80
+ static inline VALUE JavaBinParser_read_small_long(JAVA_BIN_PARSER* ptr) {
64
81
  int64_t result;
65
82
  result = ptr->tag_byte & 0x0f;
66
83
  if ((ptr->tag_byte & 0x10) != 0) {
@@ -69,12 +86,10 @@ static VALUE JavaBinParser_read_small_long(JAVA_BIN_PARSER* ptr) {
69
86
  return LL2NUM(result);
70
87
  }
71
88
 
72
- static VALUE JavaBinParser_read_string(JAVA_BIN_PARSER* ptr) {
73
- int size;
74
- int i;
89
+ static inline VALUE JavaBinParser_read_string(JAVA_BIN_PARSER* ptr) {
90
+ int size, i;
75
91
  int start;
76
92
  unsigned char b;
77
-
78
93
  size = JavaBinParser_read_size(ptr);
79
94
  start = ptr->current;
80
95
  for (i = 0; i < size; i++) {
@@ -90,125 +105,161 @@ static VALUE JavaBinParser_read_string(JAVA_BIN_PARSER* ptr) {
90
105
  return _utf8_string((const char*) &ptr->data[start], ptr->current - start);
91
106
  }
92
107
 
93
- static VALUE JavaBinParser_read_byte(JAVA_BIN_PARSER* ptr) {
108
+ static inline VALUE JavaBinParser_read_array(JAVA_BIN_PARSER* ptr) {
109
+ int size, i;
110
+ VALUE array;
111
+ size = JavaBinParser_read_size(ptr);
112
+ array = rb_ary_new();
113
+ for (i = 0; i < size; i++) {
114
+ rb_ary_push(array,JavaBinParser_read_val(ptr));
115
+ }
116
+ return array;
117
+ }
118
+
119
+ static inline VALUE JavaBinParser_read_extern_string(JAVA_BIN_PARSER* ptr) {
120
+ int size;
121
+ VALUE value;
122
+ size = JavaBinParser_read_size(ptr);
123
+ if (size == 0) {
124
+ /* rubyの文字列 */
125
+ value = JavaBinParser_read_val(ptr);
126
+ OBJ_FREEZE(value);
127
+ /* 参照文字列として文字列を保持 */
128
+ ptr->cache[ptr->cache_index++] = value;
129
+ /* 必要があれば参照文字列用のcacheを拡張する */
130
+ if (ptr->cache_size <= ptr->cache_index) {
131
+ JavaBinParser_extend_cache(ptr);
132
+ }
133
+ return value;
134
+ } else {
135
+ //return rb_str_new4(ptr->cache[size - 1]); // freeze共有
136
+ //return rb_str_new3(ptr->cache[size - 1]); // 共有(変更があったら分裂)
137
+ return ptr->cache[size - 1]; // 同じ物
138
+ //return rb_str_dup(ptr->cache[size - 1]); // コピー
139
+ }
140
+ }
141
+
142
+ static inline VALUE JavaBinParser_read_ordered_map(JAVA_BIN_PARSER* ptr) {
143
+ int size, i;
144
+ VALUE hash, key, value;
145
+ size = JavaBinParser_read_size(ptr);
146
+ hash = rb_hash_new();
147
+ for (i = 0; i < size; i++) {
148
+ key = JavaBinParser_read_val(ptr);
149
+ value = JavaBinParser_read_val(ptr);
150
+ rb_hash_aset(hash, key, value);
151
+ }
152
+ return hash;
153
+ }
154
+
155
+ static inline VALUE JavaBinParser_read_byte(JAVA_BIN_PARSER* ptr) {
94
156
  int8_t c;
95
157
  _readnumeric(ptr, c);
96
158
  return INT2FIX(*((int8_t*)&c));
97
159
  }
98
160
 
99
- static VALUE JavaBinParser_read_short(JAVA_BIN_PARSER* ptr) {
161
+ static inline VALUE JavaBinParser_read_short(JAVA_BIN_PARSER* ptr) {
100
162
  u_int16_t c;
101
163
  _readnumeric(ptr, c);
102
164
  c = _swap_16(c);
103
165
  return INT2FIX(*((int16_t*)&c));
104
166
  }
105
167
 
106
- static VALUE JavaBinParser_read_int(JAVA_BIN_PARSER* ptr) {
168
+ static inline VALUE JavaBinParser_read_int(JAVA_BIN_PARSER* ptr) {
107
169
  u_int32_t c;
108
170
  _readnumeric(ptr, c);
109
171
  c = _swap_32(c);
110
172
  return INT2NUM(*((int32_t*)&c));
111
173
  }
112
174
 
113
- static VALUE JavaBinParser_read_long(JAVA_BIN_PARSER* ptr) {
175
+ static inline VALUE JavaBinParser_read_long(JAVA_BIN_PARSER* ptr) {
114
176
  u_int64_t c;
115
177
  _readnumeric(ptr, c);
116
178
  c = _swap_64(c);
117
179
  return LL2NUM(*((int64_t*)&c));
118
180
  }
119
181
 
120
- static VALUE JavaBinParser_read_date(JAVA_BIN_PARSER* ptr) {
182
+ static inline VALUE JavaBinParser_read_date(JAVA_BIN_PARSER* ptr) {
121
183
  u_int64_t c;
122
184
  _readnumeric(ptr, c);
123
185
  c = _swap_64(c);
124
186
  return rb_funcall(rb_cTime, i_At, 1, ULL2NUM(*((int64_t*)&c) / 1000));
125
187
  }
126
188
 
127
- static VALUE JavaBinParser_read_float(JAVA_BIN_PARSER* ptr) {
189
+ static inline VALUE JavaBinParser_read_float(JAVA_BIN_PARSER* ptr) {
128
190
  u_int32_t c;
129
191
  _readnumeric(ptr, c);
130
192
  c = _swap_32(c);
131
193
  return rb_float_new((double)*((float*)&c));
132
194
  }
133
195
 
134
- static VALUE JavaBinParser_read_double(JAVA_BIN_PARSER* ptr) {
196
+ static inline VALUE JavaBinParser_read_double(JAVA_BIN_PARSER* ptr) {
135
197
  u_int64_t c;
136
198
  _readnumeric(ptr, c);
137
199
  c = _swap_64(c);
138
200
  return rb_float_new(*((double*)&c));
139
201
  }
140
202
 
141
- static void JavaBinParser_extend_cache(JAVA_BIN_PARSER* ptr) {
142
- VALUE* newP;
143
- int next_size;
144
- if (ptr->cache == NULL) {
145
- next_size = 64;
146
- } else {
147
- next_size = ptr->cache_size * 2;
203
+ static inline VALUE JavaBinParser_read_byte_array(JAVA_BIN_PARSER* ptr) {
204
+ int size, i;
205
+ VALUE array;
206
+ size = JavaBinParser_read_v_int(ptr);
207
+ array = rb_ary_new();
208
+ for (i = 0; i < size; i++) {
209
+ rb_ary_push(array, INT2FIX(_getbyte(ptr)));
148
210
  }
211
+ return array;
212
+ }
149
213
 
150
- newP = (VALUE*) malloc(next_size * sizeof(VALUE));
151
- if (!newP) {
152
- rb_raise(rb_eRuntimeError, "JavaBinParser_extend_cache - allocate error");
214
+ static inline VALUE JavaBinParser_read_map(JAVA_BIN_PARSER* ptr) {
215
+ int size, i;
216
+ VALUE hash, key, value;
217
+ size = JavaBinParser_read_v_int(ptr);
218
+ hash = rb_hash_new();
219
+ for (i = 0; i < size; i++) {
220
+ key = JavaBinParser_read_val(ptr);
221
+ value = JavaBinParser_read_val(ptr);
222
+ rb_hash_aset(hash, key, value);
153
223
  }
224
+ return hash;
225
+ }
154
226
 
155
- if (ptr->cache) {
156
- memcpy(newP, ptr->cache, sizeof(VALUE) * ptr->cache_size);
227
+ static inline VALUE JavaBinParser_read_iterator(JAVA_BIN_PARSER* ptr) {
228
+ VALUE array, value;
229
+ array = rb_ary_new();
230
+ while (1) {
231
+ value = JavaBinParser_read_val(ptr);
232
+ if (value == END_OBJ) {
233
+ break;
234
+ }
235
+ rb_ary_push(array, value);
157
236
  }
158
- ptr->cache = newP;
159
- ptr->cache_size = next_size;
237
+ return array;
160
238
  }
161
239
 
162
- static VALUE JavaBinParser_read_val(JAVA_BIN_PARSER* ptr) {
163
- int size;
164
- int i;
165
- VALUE key;
166
- VALUE value;
167
- VALUE array;
168
- VALUE hash;
240
+ static inline VALUE JavaBinParser_read_solr_doc_list(JAVA_BIN_PARSER* ptr) {
241
+ VALUE hash, array;
242
+ hash = rb_hash_new();
243
+ array = JavaBinParser_read_val(ptr);
244
+ rb_hash_aset(hash, jbp_numFound, rb_ary_entry(array, 0));
245
+ rb_hash_aset(hash, jbp_start, rb_ary_entry(array, 1));
246
+ rb_hash_aset(hash, jbp_maxScore, rb_ary_entry(array, 2));
247
+ rb_hash_aset(hash, jbp_docs, JavaBinParser_read_val(ptr));
248
+ return hash;
249
+ }
169
250
 
251
+ static VALUE JavaBinParser_read_val(JAVA_BIN_PARSER* ptr) {
170
252
  ptr->tag_byte = _getbyte(ptr);
171
253
  switch (ptr->tag_byte >> 5) { /* unsignedなので論理シフト */
172
254
  case SHIFTED_STR:
173
255
  return JavaBinParser_read_string(ptr);
174
256
  case SHIFTED_ARR:
175
- size = JavaBinParser_read_size(ptr);
176
- array = rb_ary_new();
177
- for (i = 0; i < size; i++) {
178
- value = JavaBinParser_read_val(ptr);
179
- rb_ary_push(array, value);
180
- }
181
- return array;
257
+ return JavaBinParser_read_array(ptr);
182
258
  case SHIFTED_EXTERN_STRING:
183
- size = JavaBinParser_read_size(ptr);
184
- if(size == 0) {
185
- /* rubyの文字列 */
186
- value = JavaBinParser_read_val(ptr);
187
-
188
- /* 参照文字列として文字列を保持 */
189
- ptr->cache[ptr->cache_index++] = value;
190
- /* 参照文字列用のcacheを拡張する */
191
- if (ptr->cache_size <= ptr->cache_index) {
192
- JavaBinParser_extend_cache(ptr);
193
- }
194
- return value;
195
- } else {
196
- return rb_str_new4(ptr->cache[size - 1]); // freeze共有
197
- //return rb_str_new3(ptr->cache[size - 1]); // 共有(変更があったら分裂)
198
-
199
- //return ptr->cache[size - 1]; // 同じ物
200
- //return rb_str_dup(ptr->cache[size - 1]); // コピー
201
- }
259
+ return JavaBinParser_read_extern_string(ptr);
202
260
  case SHIFTED_ORDERED_MAP:
203
261
  case SHIFTED_NAMED_LST:
204
- size = JavaBinParser_read_size(ptr);
205
- hash = rb_hash_new();
206
- for (i = 0; i < size; i++) {
207
- key = JavaBinParser_read_val(ptr);
208
- value = JavaBinParser_read_val(ptr);
209
- rb_hash_aset(hash, key, value);
210
- }
211
- return hash;
262
+ return JavaBinParser_read_ordered_map(ptr);
212
263
  case SHIFTED_SINT:
213
264
  return JavaBinParser_read_small_int(ptr);
214
265
  case SHIFTED_SLONG:
@@ -231,12 +282,7 @@ static VALUE JavaBinParser_read_val(JAVA_BIN_PARSER* ptr) {
231
282
  case DATE:
232
283
  return JavaBinParser_read_date(ptr);
233
284
  case BYTEARR:
234
- size = JavaBinParser_read_v_int(ptr);
235
- array = rb_ary_new();
236
- for (i = 0; i < size; i++) {
237
- rb_ary_push(array, INT2FIX(_getbyte(ptr)));
238
- }
239
- return array;
285
+ return JavaBinParser_read_byte_array(ptr);
240
286
  case NULL_MARK:
241
287
  return Qnil;
242
288
  case BOOL_TRUE:
@@ -244,65 +290,20 @@ static VALUE JavaBinParser_read_val(JAVA_BIN_PARSER* ptr) {
244
290
  case BOOL_FALSE:
245
291
  return Qfalse;
246
292
  case MAP:
247
- size = JavaBinParser_read_v_int(ptr);
248
- hash = rb_hash_new();
249
- for (i = 0; i < size; i++) {
250
- key = JavaBinParser_read_val(ptr);
251
- value = JavaBinParser_read_val(ptr);
252
- rb_hash_aset(hash, key, value);
253
- }
254
- return hash;
255
- case ITERATOR:
256
- array = rb_ary_new();
257
- while (1) {
258
- value = JavaBinParser_read_val(ptr);
259
- if (value == END_OBJ) {
260
- break;
261
- }
262
- rb_ary_push(array, value);
263
- }
264
- return array;
293
+ return JavaBinParser_read_map(ptr);
294
+ case ITERATOR:
295
+ return JavaBinParser_read_iterator(ptr);
265
296
  case END:
266
297
  return END_OBJ;
267
298
  case SOLRDOC:
268
299
  return JavaBinParser_read_val(ptr);
269
300
  case SOLRDOCLST:
270
- hash = rb_hash_new();
271
- value = JavaBinParser_read_val(ptr);
272
- // TODO キーのfreeze
273
- rb_hash_aset(hash, rb_str_new2("numFound"), rb_ary_entry(value, 0));
274
- rb_hash_aset(hash, rb_str_new2("start"), rb_ary_entry(value, 1));
275
- rb_hash_aset(hash, rb_str_new2("maxScore"), rb_ary_entry(value, 2));
276
- rb_hash_aset(hash, rb_str_new2("docs"), JavaBinParser_read_val(ptr));
277
- return hash;
301
+ return JavaBinParser_read_solr_doc_list(ptr);
278
302
  default:
279
303
  rb_raise(rb_eRuntimeError, "JavaBinParser_read_val - unknown tag type");
280
304
  }
281
305
  }
282
306
 
283
- static void JavaBinParser_free(JAVA_BIN_PARSER* ptr) {
284
- if (ptr) {
285
- //free(ptr->data);
286
- if (ptr->cache) {
287
- free(ptr->cache);
288
- }
289
- free(ptr);
290
- }
291
- }
292
-
293
- static void JavaBinParser_mark(JAVA_BIN_PARSER* ptr) {
294
- int i;
295
- if (ptr) {
296
- for (i = 0; i < ptr->cache_index; i++) {
297
- rb_gc_mark_maybe(ptr->cache[i]);
298
- }
299
- }
300
- }
301
-
302
- static VALUE JavaBinParser_alloc(VALUE klass) {
303
- return Data_Wrap_Struct(klass, JavaBinParser_mark, JavaBinParser_free, NULL);
304
- }
305
-
306
307
  /*
307
308
  * rubyメソッド
308
309
  */
@@ -327,11 +328,6 @@ static VALUE rb_cParser_parse(VALUE self, VALUE data) {
327
328
  rb_raise(rb_eRuntimeError, "rb_cParser_parse - data is empty.");
328
329
  }
329
330
 
330
- //ptr->data = (unsigned char*) malloc(dataLen);
331
- //if (!ptr->data) {
332
- // rb_raise(rb_eRuntimeError, "rb_cParser_parse - allocate error");
333
- //}
334
- //memcpy(ptr->data, ptrData, dataLen);
335
331
  ptr->data = (unsigned char*)ptrData;
336
332
  ptr->data_len = dataLen;
337
333
 
@@ -344,17 +340,13 @@ static VALUE rb_cParser_parse(VALUE self, VALUE data) {
344
340
  ptr->tag_byte = 0;
345
341
 
346
342
  /*
347
- * 参照文字列既に確保している場合は解放
348
- * HINT. インスタンスを使いまわす時に発生する
343
+ * 参照文字列保持、既に確保している場合は使いまわす。
344
+ * 確保していない場合は初回分を確保
349
345
  */
350
- if (ptr->cache) {
351
- free(ptr->cache);
352
- }
353
-
354
- /* 参照文字列の準備 */
355
- ptr->cache = NULL;
356
346
  ptr->cache_index = 0;
357
- JavaBinParser_extend_cache(ptr);
347
+ if (!ptr->cache) {
348
+ JavaBinParser_extend_cache(ptr);
349
+ }
358
350
 
359
351
  return JavaBinParser_read_val(ptr);
360
352
  }
@@ -369,13 +361,36 @@ static VALUE rb_cParser_initialize(VALUE self) {
369
361
  }
370
362
  DATA_PTR(self) = ptr;
371
363
 
372
- /* 参照文字列の準備(ここでも初期化しておかないと、たまにsegvしちゃいますruby 1.8.7) */
364
+ /* 参照文字列の準備 */
373
365
  ptr->cache = NULL;
366
+ ptr->cache_size = 0;
374
367
  ptr->cache_index = 0;
375
368
 
376
369
  return self;
377
370
  }
378
371
 
372
+ static void JavaBinParser_free(JAVA_BIN_PARSER* ptr) {
373
+ if (ptr) {
374
+ if (ptr->cache) {
375
+ free(ptr->cache);
376
+ }
377
+ free(ptr);
378
+ }
379
+ }
380
+
381
+ static void JavaBinParser_mark(JAVA_BIN_PARSER* ptr) {
382
+ int i;
383
+ if (ptr) {
384
+ for (i = 0; i < ptr->cache_index; i++) {
385
+ rb_gc_mark_maybe(ptr->cache[i]);
386
+ }
387
+ }
388
+ }
389
+
390
+ static VALUE JavaBinParser_alloc(VALUE klass) {
391
+ return Data_Wrap_Struct(klass, JavaBinParser_mark, JavaBinParser_free, NULL);
392
+ }
393
+
379
394
  /*
380
395
  * エントリーポイント
381
396
  */
@@ -389,12 +404,31 @@ void Init_parser(void) {
389
404
  rb_mJavaBin = rb_define_module("JavaBin");
390
405
  rb_mExt = rb_define_module_under(rb_mJavaBin, "Ext");
391
406
  rb_cParser = rb_define_class_under(rb_mExt, "Parser", rb_cObject);
392
-
407
+
393
408
  /* メモリーアロケーター設定 */
394
409
  rb_define_alloc_func(rb_cParser, JavaBinParser_alloc);
395
410
  /* コンストラクタ */
396
411
  rb_define_method(rb_cParser, "initialize", rb_cParser_initialize, 0);
397
412
  /* parseメソッド*/
398
413
  rb_define_method(rb_cParser, "parse", rb_cParser_parse, 1);
414
+
415
+ /* 繰り返し使うので変数&定数化 */
416
+ /* HINT 定数にするとGCの対象にならないっぽいので */
417
+ rb_define_const(rb_cParser, "NUM_FOUND", rb_str_new2("numFound"));
418
+ jbp_numFound = rb_const_get(rb_cParser, rb_intern("NUM_FOUND"));
419
+ rb_define_const(rb_cParser, "START", rb_str_new2("start"));
420
+ jbp_start = rb_const_get(rb_cParser, rb_intern("START"));
421
+ rb_define_const(rb_cParser, "MAX_SCORE", rb_str_new2("maxScore"));
422
+ jbp_maxScore = rb_const_get(rb_cParser, rb_intern("MAX_SCORE"));
423
+ rb_define_const(rb_cParser, "DOCS", rb_str_new2("docs"));
424
+ jbp_docs = rb_const_get(rb_cParser, rb_intern("DOCS"));
425
+ OBJ_FREEZE(jbp_numFound);
426
+ OBJ_FREEZE(jbp_start);
427
+ OBJ_FREEZE(jbp_maxScore);
428
+ OBJ_FREEZE(jbp_docs);
429
+
430
+ rb_define_const(rb_cParser, "TERMINATOR", rb_str_new2("terminator")); // iterator終端用のオブジェクト
431
+ jbp_terminator = rb_const_get(rb_cParser, rb_intern("TERMINATOR"));
432
+ OBJ_FREEZE(jbp_terminator);
399
433
  }
400
434
 
@@ -44,7 +44,7 @@
44
44
  #define EXTERN_STRING (7U << 5)
45
45
 
46
46
  /* HINT. 終端判定用オブジェクト */
47
- #define END_OBJ ((int) NULL)
47
+ #define END_OBJ (jbp_terminator)
48
48
 
49
49
  /* HINT. 先に計算しておく(unsignedなので論理シフト) */
50
50
  #define SHIFTED_STR (STR >> 5)
@@ -114,24 +114,35 @@ typedef struct java_bin_parser {
114
114
  typedef unsigned __int64 u_int64_t;
115
115
  #endif
116
116
 
117
- static int32_t JavaBinParser_read_v_int(JAVA_BIN_PARSER* ptr);
118
- static int64_t JavaBinParser_read_v_long(JAVA_BIN_PARSER* ptr);
119
- static int JavaBinParser_read_size(JAVA_BIN_PARSER* ptr);
120
- static VALUE JavaBinParser_read_small_int(JAVA_BIN_PARSER* ptr);
121
- static VALUE JavaBinParser_read_small_long(JAVA_BIN_PARSER* ptr);
122
- static VALUE JavaBinParser_read_string(JAVA_BIN_PARSER* ptr);
123
- static VALUE JavaBinParser_read_byte(JAVA_BIN_PARSER* ptr);
124
- static VALUE JavaBinParser_read_short(JAVA_BIN_PARSER* ptr);
125
- static VALUE JavaBinParser_read_int(JAVA_BIN_PARSER* ptr);
126
- static VALUE JavaBinParser_read_long(JAVA_BIN_PARSER* ptr);
127
- static VALUE JavaBinParser_read_date(JAVA_BIN_PARSER* ptr);
128
- static VALUE JavaBinParser_read_float(JAVA_BIN_PARSER* ptr);
129
- static VALUE JavaBinParser_read_double(JAVA_BIN_PARSER* ptr);
117
+ //static void JavaBinParser_extend_cache(JAVA_BIN_PARSER* ptr);
118
+
119
+ //static int32_t JavaBinParser_read_v_int(JAVA_BIN_PARSER* ptr);
120
+ //static int64_t JavaBinParser_read_v_long(JAVA_BIN_PARSER* ptr);
121
+ //static int JavaBinParser_read_size(JAVA_BIN_PARSER* ptr);
122
+ //static VALUE JavaBinParser_read_small_int(JAVA_BIN_PARSER* ptr);
123
+ //static VALUE JavaBinParser_read_small_long(JAVA_BIN_PARSER* ptr);
124
+ //static VALUE JavaBinParser_read_string(JAVA_BIN_PARSER* ptr);
125
+ //static VALUE JavaBinParser_read_array(JAVA_BIN_PARSER* ptr);
126
+ //static VALUE JavaBinParser_read_extern_string(JAVA_BIN_PARSER* ptr);
127
+ //static VALUE JavaBinParser_read_ordered_map(JAVA_BIN_PARSER* ptr);
128
+ //static VALUE JavaBinParser_read_byte(JAVA_BIN_PARSER* ptr);
129
+ //static VALUE JavaBinParser_read_short(JAVA_BIN_PARSER* ptr);
130
+ //static VALUE JavaBinParser_read_int(JAVA_BIN_PARSER* ptr);
131
+ //static VALUE JavaBinParser_read_long(JAVA_BIN_PARSER* ptr);
132
+ //static VALUE JavaBinParser_read_date(JAVA_BIN_PARSER* ptr);
133
+ //static VALUE JavaBinParser_read_float(JAVA_BIN_PARSER* ptr);
134
+ //static VALUE JavaBinParser_read_double(JAVA_BIN_PARSER* ptr);
135
+ //static VALUE JavaBinParser_read_byte_array(JAVA_BIN_PARSER* ptr);
136
+ //static VALUE JavaBinParser_read_map(JAVA_BIN_PARSER* ptr);
137
+ //static VALUE JavaBinParser_read_iterator(JAVA_BIN_PARSER* ptr);
138
+ //static VALUE JavaBinParser_read_solr_doc_list(JAVA_BIN_PARSER* ptr);
139
+
130
140
  static VALUE JavaBinParser_read_val(JAVA_BIN_PARSER* ptr);
141
+
131
142
  static void JavaBinParser_free(JAVA_BIN_PARSER* ptr);
132
143
  static void JavaBinParser_mark(JAVA_BIN_PARSER* ptr);
133
144
  static VALUE JavaBinParser_alloc(VALUE klass);
134
- static void JavaBinParser_extend_cache(JAVA_BIN_PARSER* ptr);
145
+
135
146
  static VALUE rb_cParser_parse(VALUE self, VALUE data);
136
147
  static VALUE rb_cParser_initialize(VALUE self);
137
148
 
data/java_bin.gemspec CHANGED
@@ -5,11 +5,11 @@
5
5
 
6
6
  Gem::Specification.new do |s|
7
7
  s.name = %q{java_bin}
8
- s.version = "0.3.2"
8
+ s.version = "0.3.3"
9
9
 
10
10
  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
11
11
  s.authors = ["kennyj"]
12
- s.date = %q{2010-01-26}
12
+ s.date = %q{2010-02-02}
13
13
  s.description = %q{Apache Solr JavaBin format (binary format) implementation for Ruby.}
14
14
  s.email = %q{kennyj@gmail.com}
15
15
  s.extensions = ["ext/java_bin/ext/extconf.rb"]
@@ -193,7 +193,7 @@ class TestJavaBinParser < Test::Unit::TestCase
193
193
  end
194
194
 
195
195
  def test_iterator
196
- assert_equal([0, 127, nil, true], @parser.parse([1, 14, 3, 0, 3, 127, 0, 1,15].pack("C*")))
196
+ assert_equal([0, 127, nil, true, false], @parser.parse([1, 14, 3, 0, 3, 127, 0, 1, 2, 15].pack("C*")))
197
197
  end
198
198
 
199
199
  # def test_term
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: java_bin
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.3.2
4
+ version: 0.3.3
5
5
  platform: ruby
6
6
  authors:
7
7
  - kennyj
@@ -9,7 +9,7 @@ autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
11
 
12
- date: 2010-01-26 00:00:00 +09:00
12
+ date: 2010-02-02 00:00:00 +09:00
13
13
  default_executable:
14
14
  dependencies: []
15
15