java_bin 0.3.2 → 0.3.3

Sign up to get free protection for your applications and to get access to all the features.
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