Ruby 3.5.0dev (2025-10-06 revision 704677257ecb01c7ee10aa0dfc55ca1d4fc4636d)
struct.c (704677257ecb01c7ee10aa0dfc55ca1d4fc4636d)
1/**********************************************************************
2
3 struct.c -
4
5 $Author$
6 created at: Tue Mar 22 18:44:30 JST 1995
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9
10**********************************************************************/
11
12#include "id.h"
13#include "internal.h"
14#include "internal/class.h"
15#include "internal/error.h"
16#include "internal/hash.h"
17#include "internal/object.h"
18#include "internal/proc.h"
19#include "internal/struct.h"
20#include "internal/symbol.h"
21#include "vm_core.h"
22#include "builtin.h"
23
24/* only for struct[:field] access */
25enum {
26 AREF_HASH_UNIT = 5,
27 AREF_HASH_THRESHOLD = 10
28};
29
30/* Note: Data is a stricter version of the Struct: no attr writers & no
31 hash-alike/array-alike behavior. It shares most of the implementation
32 on the C level, but is unrelated on the Ruby level. */
34static VALUE rb_cData;
35static ID id_members, id_back_members, id_keyword_init;
36
37static VALUE struct_alloc(VALUE);
38
39static inline VALUE
40struct_ivar_get(VALUE c, ID id)
41{
42 VALUE orig = c;
43 VALUE ivar = rb_attr_get(c, id);
44
45 if (!NIL_P(ivar))
46 return ivar;
47
48 for (;;) {
50 if (c == rb_cStruct || c == rb_cData || !RTEST(c))
51 return Qnil;
53 ivar = rb_attr_get(c, id);
54 if (!NIL_P(ivar)) {
55 if (!OBJ_FROZEN(orig)) rb_ivar_set(orig, id, ivar);
56 return ivar;
57 }
58 }
59}
60
62rb_struct_s_keyword_init(VALUE klass)
63{
64 return struct_ivar_get(klass, id_keyword_init);
65}
66
69{
70 VALUE members = struct_ivar_get(klass, id_members);
71
72 if (NIL_P(members)) {
73 rb_raise(rb_eTypeError, "uninitialized struct");
74 }
75 if (!RB_TYPE_P(members, T_ARRAY)) {
76 rb_raise(rb_eTypeError, "corrupted struct");
77 }
78 return members;
79}
80
83{
85
86 if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
87 rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
88 RARRAY_LEN(members), RSTRUCT_LEN(s));
89 }
90 return members;
91}
92
93static long
94struct_member_pos_ideal(VALUE name, long mask)
95{
96 /* (id & (mask/2)) * 2 */
97 return (SYM2ID(name) >> (ID_SCOPE_SHIFT - 1)) & mask;
98}
99
100static long
101struct_member_pos_probe(long prev, long mask)
102{
103 /* (((prev/2) * AREF_HASH_UNIT + 1) & (mask/2)) * 2 */
104 return (prev * AREF_HASH_UNIT + 2) & mask;
105}
106
107static VALUE
108struct_set_members(VALUE klass, VALUE /* frozen hidden array */ members)
109{
110 VALUE back;
111 const long members_length = RARRAY_LEN(members);
112
113 if (members_length <= AREF_HASH_THRESHOLD) {
114 back = members;
115 }
116 else {
117 long i, j, mask = 64;
118 VALUE name;
119
120 while (mask < members_length * AREF_HASH_UNIT) mask *= 2;
121
122 back = rb_ary_hidden_new(mask + 1);
123 rb_ary_store(back, mask, INT2FIX(members_length));
124 mask -= 2; /* mask = (2**k-1)*2 */
125
126 for (i=0; i < members_length; i++) {
127 name = RARRAY_AREF(members, i);
128
129 j = struct_member_pos_ideal(name, mask);
130
131 for (;;) {
132 if (!RTEST(RARRAY_AREF(back, j))) {
133 rb_ary_store(back, j, name);
134 rb_ary_store(back, j + 1, INT2FIX(i));
135 break;
136 }
137 j = struct_member_pos_probe(j, mask);
138 }
139 }
140 OBJ_FREEZE(back);
141 }
142 rb_ivar_set(klass, id_members, members);
143 rb_ivar_set(klass, id_back_members, back);
144
145 return members;
146}
147
148static inline int
149struct_member_pos(VALUE s, VALUE name)
150{
151 VALUE back = struct_ivar_get(rb_obj_class(s), id_back_members);
152 long j, mask;
153
154 if (UNLIKELY(NIL_P(back))) {
155 rb_raise(rb_eTypeError, "uninitialized struct");
156 }
157 if (UNLIKELY(!RB_TYPE_P(back, T_ARRAY))) {
158 rb_raise(rb_eTypeError, "corrupted struct");
159 }
160
161 mask = RARRAY_LEN(back);
162
163 if (mask <= AREF_HASH_THRESHOLD) {
164 if (UNLIKELY(RSTRUCT_LEN(s) != mask)) {
165 rb_raise(rb_eTypeError,
166 "struct size differs (%ld required %ld given)",
167 mask, RSTRUCT_LEN(s));
168 }
169 for (j = 0; j < mask; j++) {
170 if (RARRAY_AREF(back, j) == name)
171 return (int)j;
172 }
173 return -1;
174 }
175
176 if (UNLIKELY(RSTRUCT_LEN(s) != FIX2INT(RARRAY_AREF(back, mask-1)))) {
177 rb_raise(rb_eTypeError, "struct size differs (%d required %ld given)",
178 FIX2INT(RARRAY_AREF(back, mask-1)), RSTRUCT_LEN(s));
179 }
180
181 mask -= 3;
182 j = struct_member_pos_ideal(name, mask);
183
184 for (;;) {
185 VALUE e = RARRAY_AREF(back, j);
186 if (e == name)
187 return FIX2INT(RARRAY_AREF(back, j + 1));
188 if (!RTEST(e)) {
189 return -1;
190 }
191 j = struct_member_pos_probe(j, mask);
192 }
193}
194
195/*
196 * call-seq:
197 * StructClass::members -> array_of_symbols
198 *
199 * Returns the member names of the Struct descendant as an array:
200 *
201 * Customer = Struct.new(:name, :address, :zip)
202 * Customer.members # => [:name, :address, :zip]
203 *
204 */
205
206static VALUE
207rb_struct_s_members_m(VALUE klass)
208{
209 VALUE members = rb_struct_s_members(klass);
210
211 return rb_ary_dup(members);
212}
213
214/*
215 * call-seq:
216 * members -> array_of_symbols
217 *
218 * Returns the member names from +self+ as an array:
219 *
220 * Customer = Struct.new(:name, :address, :zip)
221 * Customer.new.members # => [:name, :address, :zip]
222 *
223 * Related: #to_a.
224 */
225
226static VALUE
227rb_struct_members_m(VALUE obj)
228{
229 return rb_struct_s_members_m(rb_obj_class(obj));
230}
231
232VALUE
234{
235 VALUE slot = ID2SYM(id);
236 int i = struct_member_pos(obj, slot);
237 if (i != -1) {
238 return RSTRUCT_GET(obj, i);
239 }
240 rb_name_err_raise("'%1$s' is not a struct member", obj, ID2SYM(id));
241
243}
244
245static void
246rb_struct_modify(VALUE s)
247{
248 rb_check_frozen(s);
249}
250
251static VALUE
252anonymous_struct(VALUE klass)
253{
254 VALUE nstr;
255
256 nstr = rb_class_new(klass);
257 rb_make_metaclass(nstr, RBASIC(klass)->klass);
258 rb_class_inherited(klass, nstr);
259 return nstr;
260}
261
262static VALUE
263new_struct(VALUE name, VALUE super)
264{
265 /* old style: should we warn? */
266 ID id;
267 name = rb_str_to_str(name);
268 if (!rb_is_const_name(name)) {
269 rb_name_err_raise("identifier %1$s needs to be constant",
270 super, name);
271 }
272 id = rb_to_id(name);
273 if (rb_const_defined_at(super, id)) {
274 rb_warn("redefining constant %"PRIsVALUE"::%"PRIsVALUE, super, name);
275 rb_mod_remove_const(super, ID2SYM(id));
276 }
277 return rb_define_class_id_under_no_pin(super, id, super);
278}
279
280NORETURN(static void invalid_struct_pos(VALUE s, VALUE idx));
281
282static void
283define_aref_method(VALUE nstr, VALUE name, VALUE off)
284{
285 rb_add_method_optimized(nstr, SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_AREF, FIX2UINT(off), METHOD_VISI_PUBLIC);
286}
287
288static void
289define_aset_method(VALUE nstr, VALUE name, VALUE off)
290{
291 rb_add_method_optimized(nstr, SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_ASET, FIX2UINT(off), METHOD_VISI_PUBLIC);
292}
293
294static VALUE
295rb_struct_s_inspect(VALUE klass)
296{
297 VALUE inspect = rb_class_name(klass);
298 if (RTEST(rb_struct_s_keyword_init(klass))) {
299 rb_str_cat_cstr(inspect, "(keyword_init: true)");
300 }
301 return inspect;
302}
303
304static VALUE
305rb_data_s_new(int argc, const VALUE *argv, VALUE klass)
306{
307 if (rb_keyword_given_p()) {
308 if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
309 rb_error_arity(argc, 0, 0);
310 }
311 return rb_class_new_instance_pass_kw(argc, argv, klass);
312 }
313 else {
314 VALUE members = struct_ivar_get(klass, id_members);
315 int num_members = RARRAY_LENINT(members);
316
317 rb_check_arity(argc, 0, num_members);
318 VALUE arg_hash = rb_hash_new_with_size(argc);
319 for (long i=0; i<argc; i++) {
320 VALUE k = rb_ary_entry(members, i), v = argv[i];
321 rb_hash_aset(arg_hash, k, v);
322 }
323 return rb_class_new_instance_kw(1, &arg_hash, klass, RB_PASS_KEYWORDS);
324 }
325}
326
327#if 0 /* for RDoc */
328
329/*
330 * call-seq:
331 * StructClass::keyword_init? -> true or falsy value
332 *
333 * Returns +true+ if the class was initialized with <tt>keyword_init: true</tt>.
334 * Otherwise returns +nil+ or +false+.
335 *
336 * Examples:
337 * Foo = Struct.new(:a)
338 * Foo.keyword_init? # => nil
339 * Bar = Struct.new(:a, keyword_init: true)
340 * Bar.keyword_init? # => true
341 * Baz = Struct.new(:a, keyword_init: false)
342 * Baz.keyword_init? # => false
343 */
344static VALUE
345rb_struct_s_keyword_init_p(VALUE obj)
346{
347}
348#endif
349
350#define rb_struct_s_keyword_init_p rb_struct_s_keyword_init
351
352static VALUE
353setup_struct(VALUE nstr, VALUE members)
354{
355 long i, len;
356
357 members = struct_set_members(nstr, members);
358
359 rb_define_alloc_func(nstr, struct_alloc);
362 rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0);
363 rb_define_singleton_method(nstr, "inspect", rb_struct_s_inspect, 0);
364 rb_define_singleton_method(nstr, "keyword_init?", rb_struct_s_keyword_init_p, 0);
365
366 len = RARRAY_LEN(members);
367 for (i=0; i< len; i++) {
368 VALUE sym = RARRAY_AREF(members, i);
369 ID id = SYM2ID(sym);
370 VALUE off = LONG2NUM(i);
371
372 define_aref_method(nstr, sym, off);
373 define_aset_method(nstr, ID2SYM(rb_id_attrset(id)), off);
374 }
375
376 return nstr;
377}
378
379static VALUE
380setup_data(VALUE subclass, VALUE members)
381{
382 long i, len;
383
384 members = struct_set_members(subclass, members);
385
386 rb_define_alloc_func(subclass, struct_alloc);
387 VALUE sclass = rb_singleton_class(subclass);
388 rb_undef_method(sclass, "define");
389 rb_define_method(sclass, "new", rb_data_s_new, -1);
390 rb_define_method(sclass, "[]", rb_data_s_new, -1);
391 rb_define_method(sclass, "members", rb_struct_s_members_m, 0);
392 rb_define_method(sclass, "inspect", rb_struct_s_inspect, 0); // FIXME: just a separate method?..
393
394 len = RARRAY_LEN(members);
395 for (i=0; i< len; i++) {
396 VALUE sym = RARRAY_AREF(members, i);
397 VALUE off = LONG2NUM(i);
398
399 define_aref_method(subclass, sym, off);
400 }
401
402 return subclass;
403}
404
405VALUE
407{
408 return struct_alloc(klass);
409}
410
411static VALUE
412struct_make_members_list(va_list ar)
413{
414 char *mem;
415 VALUE ary, list = rb_ident_hash_new();
416 RBASIC_CLEAR_CLASS(list);
417 while ((mem = va_arg(ar, char*)) != 0) {
418 VALUE sym = rb_sym_intern_ascii_cstr(mem);
419 if (RTEST(rb_hash_has_key(list, sym))) {
420 rb_raise(rb_eArgError, "duplicate member: %s", mem);
421 }
422 rb_hash_aset(list, sym, Qtrue);
423 }
424 ary = rb_hash_keys(list);
425 RBASIC_CLEAR_CLASS(ary);
426 OBJ_FREEZE(ary);
427 return ary;
428}
429
430static VALUE
431struct_define_without_accessor(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, VALUE members)
432{
433 VALUE klass;
434
435 if (class_name) {
436 if (outer) {
437 klass = rb_define_class_under(outer, class_name, super);
438 }
439 else {
440 klass = rb_define_class(class_name, super);
441 }
442 }
443 else {
444 klass = anonymous_struct(super);
445 }
446
447 struct_set_members(klass, members);
448
449 if (alloc) {
450 rb_define_alloc_func(klass, alloc);
451 }
452 else {
453 rb_define_alloc_func(klass, struct_alloc);
454 }
455
456 return klass;
457}
458
459VALUE
460rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, ...)
461{
462 va_list ar;
463 VALUE members;
464
465 va_start(ar, alloc);
466 members = struct_make_members_list(ar);
467 va_end(ar);
468
469 return struct_define_without_accessor(outer, class_name, super, alloc, members);
470}
471
472VALUE
473rb_struct_define_without_accessor(const char *class_name, VALUE super, rb_alloc_func_t alloc, ...)
474{
475 va_list ar;
476 VALUE members;
477
478 va_start(ar, alloc);
479 members = struct_make_members_list(ar);
480 va_end(ar);
481
482 return struct_define_without_accessor(0, class_name, super, alloc, members);
483}
484
485VALUE
486rb_struct_define(const char *name, ...)
487{
488 va_list ar;
489 VALUE st, ary;
490
491 va_start(ar, name);
492 ary = struct_make_members_list(ar);
493 va_end(ar);
494
495 if (!name) {
496 st = anonymous_struct(rb_cStruct);
497 }
498 else {
499 st = new_struct(rb_str_new2(name), rb_cStruct);
500 rb_vm_register_global_object(st);
501 }
502 return setup_struct(st, ary);
503}
504
505VALUE
506rb_struct_define_under(VALUE outer, const char *name, ...)
507{
508 va_list ar;
509 VALUE ary;
510
511 va_start(ar, name);
512 ary = struct_make_members_list(ar);
513 va_end(ar);
514
515 return setup_struct(rb_define_class_id_under(outer, rb_intern(name), rb_cStruct), ary);
516}
517
518/*
519 * call-seq:
520 * Struct.new(*member_names, keyword_init: nil){|Struct_subclass| ... } -> Struct_subclass
521 * Struct.new(class_name, *member_names, keyword_init: nil){|Struct_subclass| ... } -> Struct_subclass
522 * Struct_subclass.new(*member_names) -> Struct_subclass_instance
523 * Struct_subclass.new(**member_names) -> Struct_subclass_instance
524 *
525 * <tt>Struct.new</tt> returns a new subclass of +Struct+. The new subclass:
526 *
527 * - May be anonymous, or may have the name given by +class_name+.
528 * - May have members as given by +member_names+.
529 * - May have initialization via ordinary arguments, or via keyword arguments
530 *
531 * The new subclass has its own method <tt>::new</tt>; thus:
532 *
533 * Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
534 * f = Foo.new(0, 1) # => #<struct Struct::Foo foo=0, bar=1>
535 *
536 * <b>Class Name</b>
537 *
538 * With string argument +class_name+,
539 * returns a new subclass of +Struct+ named <tt>Struct::<em>class_name</em></tt>:
540 *
541 * Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
542 * Foo.name # => "Struct::Foo"
543 * Foo.superclass # => Struct
544 *
545 * Without string argument +class_name+,
546 * returns a new anonymous subclass of +Struct+:
547 *
548 * Struct.new(:foo, :bar).name # => nil
549 *
550 * <b>Block</b>
551 *
552 * With a block given, the created subclass is yielded to the block:
553 *
554 * Customer = Struct.new('Customer', :name, :address) do |new_class|
555 * p "The new subclass is #{new_class}"
556 * def greeting
557 * "Hello #{name} at #{address}"
558 * end
559 * end # => Struct::Customer
560 * dave = Customer.new('Dave', '123 Main')
561 * dave # => #<struct Struct::Customer name="Dave", address="123 Main">
562 * dave.greeting # => "Hello Dave at 123 Main"
563 *
564 * Output, from <tt>Struct.new</tt>:
565 *
566 * "The new subclass is Struct::Customer"
567 *
568 * <b>Member Names</b>
569 *
570 * Symbol arguments +member_names+
571 * determines the members of the new subclass:
572 *
573 * Struct.new(:foo, :bar).members # => [:foo, :bar]
574 * Struct.new('Foo', :foo, :bar).members # => [:foo, :bar]
575 *
576 * The new subclass has instance methods corresponding to +member_names+:
577 *
578 * Foo = Struct.new('Foo', :foo, :bar)
579 * Foo.instance_methods(false) # => [:foo, :bar, :foo=, :bar=]
580 * f = Foo.new # => #<struct Struct::Foo foo=nil, bar=nil>
581 * f.foo # => nil
582 * f.foo = 0 # => 0
583 * f.bar # => nil
584 * f.bar = 1 # => 1
585 * f # => #<struct Struct::Foo foo=0, bar=1>
586 *
587 * <b>Singleton Methods</b>
588 *
589 * A subclass returned by Struct.new has these singleton methods:
590 *
591 * - Method <tt>::new </tt> creates an instance of the subclass:
592 *
593 * Foo.new # => #<struct Struct::Foo foo=nil, bar=nil>
594 * Foo.new(0) # => #<struct Struct::Foo foo=0, bar=nil>
595 * Foo.new(0, 1) # => #<struct Struct::Foo foo=0, bar=1>
596 * Foo.new(0, 1, 2) # Raises ArgumentError: struct size differs
597 *
598 * # Initialization with keyword arguments:
599 * Foo.new(foo: 0) # => #<struct Struct::Foo foo=0, bar=nil>
600 * Foo.new(foo: 0, bar: 1) # => #<struct Struct::Foo foo=0, bar=1>
601 * Foo.new(foo: 0, bar: 1, baz: 2)
602 * # Raises ArgumentError: unknown keywords: baz
603 *
604 * - Method <tt>:inspect</tt> returns a string representation of the subclass:
605 *
606 * Foo.inspect
607 * # => "Struct::Foo"
608 *
609 * - Method <tt>::members</tt> returns an array of the member names:
610 *
611 * Foo.members # => [:foo, :bar]
612 *
613 * <b>Keyword Argument</b>
614 *
615 * By default, the arguments for initializing an instance of the new subclass
616 * can be both positional and keyword arguments.
617 *
618 * Optional keyword argument <tt>keyword_init:</tt> allows to force only one
619 * type of arguments to be accepted:
620 *
621 * KeywordsOnly = Struct.new(:foo, :bar, keyword_init: true)
622 * KeywordsOnly.new(bar: 1, foo: 0)
623 * # => #<struct KeywordsOnly foo=0, bar=1>
624 * KeywordsOnly.new(0, 1)
625 * # Raises ArgumentError: wrong number of arguments
626 *
627 * PositionalOnly = Struct.new(:foo, :bar, keyword_init: false)
628 * PositionalOnly.new(0, 1)
629 * # => #<struct PositionalOnly foo=0, bar=1>
630 * PositionalOnly.new(bar: 1, foo: 0)
631 * # => #<struct PositionalOnly foo={:foo=>1, :bar=>2}, bar=nil>
632 * # Note that no error is raised, but arguments treated as one hash value
633 *
634 * # Same as not providing keyword_init:
635 * Any = Struct.new(:foo, :bar, keyword_init: nil)
636 * Any.new(foo: 1, bar: 2)
637 * # => #<struct Any foo=1, bar=2>
638 * Any.new(1, 2)
639 * # => #<struct Any foo=1, bar=2>
640 */
641
642static VALUE
643rb_struct_s_def(int argc, VALUE *argv, VALUE klass)
644{
645 VALUE name = Qnil, rest, keyword_init = Qnil;
646 long i;
647 VALUE st;
648 VALUE opt;
649
650 argc = rb_scan_args(argc, argv, "0*:", NULL, &opt);
651 if (argc >= 1 && !SYMBOL_P(argv[0])) {
652 name = argv[0];
653 --argc;
654 ++argv;
655 }
656
657 if (!NIL_P(opt)) {
658 static ID keyword_ids[1];
659
660 if (!keyword_ids[0]) {
661 keyword_ids[0] = rb_intern("keyword_init");
662 }
663 rb_get_kwargs(opt, keyword_ids, 0, 1, &keyword_init);
664 if (UNDEF_P(keyword_init)) {
665 keyword_init = Qnil;
666 }
667 else if (RTEST(keyword_init)) {
668 keyword_init = Qtrue;
669 }
670 }
671
672 rest = rb_ident_hash_new();
673 RBASIC_CLEAR_CLASS(rest);
674 for (i=0; i<argc; i++) {
675 VALUE mem = rb_to_symbol(argv[i]);
676 if (rb_is_attrset_sym(mem)) {
677 rb_raise(rb_eArgError, "invalid struct member: %"PRIsVALUE, mem);
678 }
679 if (RTEST(rb_hash_has_key(rest, mem))) {
680 rb_raise(rb_eArgError, "duplicate member: %"PRIsVALUE, mem);
681 }
682 rb_hash_aset(rest, mem, Qtrue);
683 }
684 rest = rb_hash_keys(rest);
685 RBASIC_CLEAR_CLASS(rest);
686 OBJ_FREEZE(rest);
687 if (NIL_P(name)) {
688 st = anonymous_struct(klass);
689 }
690 else {
691 st = new_struct(name, klass);
692 }
693 setup_struct(st, rest);
694 rb_ivar_set(st, id_keyword_init, keyword_init);
695 if (rb_block_given_p()) {
696 rb_mod_module_eval(0, 0, st);
697 }
698
699 return st;
700}
701
702static long
703num_members(VALUE klass)
704{
705 VALUE members;
706 members = struct_ivar_get(klass, id_members);
707 if (!RB_TYPE_P(members, T_ARRAY)) {
708 rb_raise(rb_eTypeError, "broken members");
709 }
710 return RARRAY_LEN(members);
711}
712
713/*
714 */
715
717 VALUE self;
718 VALUE unknown_keywords;
719};
720
721static int rb_struct_pos(VALUE s, VALUE *name);
722
723static int
724struct_hash_set_i(VALUE key, VALUE val, VALUE arg)
725{
726 struct struct_hash_set_arg *args = (struct struct_hash_set_arg *)arg;
727 int i = rb_struct_pos(args->self, &key);
728 if (i < 0) {
729 if (NIL_P(args->unknown_keywords)) {
730 args->unknown_keywords = rb_ary_new();
731 }
732 rb_ary_push(args->unknown_keywords, key);
733 }
734 else {
735 rb_struct_modify(args->self);
736 RSTRUCT_SET(args->self, i, val);
737 }
738 return ST_CONTINUE;
739}
740
741static VALUE
742rb_struct_initialize_m(int argc, const VALUE *argv, VALUE self)
743{
744 VALUE klass = rb_obj_class(self);
745 rb_struct_modify(self);
746 long n = num_members(klass);
747 if (argc == 0) {
748 rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self), n);
749 return Qnil;
750 }
751
752 bool keyword_init = false;
753 switch (rb_struct_s_keyword_init(klass)) {
754 default:
755 if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
756 rb_error_arity(argc, 0, 0);
757 }
758 keyword_init = true;
759 break;
760 case Qfalse:
761 break;
762 case Qnil:
763 if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
764 break;
765 }
766 keyword_init = rb_keyword_given_p();
767 break;
768 }
769 if (keyword_init) {
770 struct struct_hash_set_arg arg;
771 rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self), n);
772 arg.self = self;
773 arg.unknown_keywords = Qnil;
774 rb_hash_foreach(argv[0], struct_hash_set_i, (VALUE)&arg);
775 if (arg.unknown_keywords != Qnil) {
776 rb_raise(rb_eArgError, "unknown keywords: %s",
777 RSTRING_PTR(rb_ary_join(arg.unknown_keywords, rb_str_new2(", "))));
778 }
779 }
780 else {
781 if (n < argc) {
782 rb_raise(rb_eArgError, "struct size differs");
783 }
784 for (long i=0; i<argc; i++) {
785 RSTRUCT_SET(self, i, argv[i]);
786 }
787 if (n > argc) {
788 rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self)+argc, n-argc);
789 }
790 }
791 return Qnil;
792}
793
794VALUE
796{
797 rb_struct_initialize_m(RARRAY_LENINT(values), RARRAY_CONST_PTR(values), self);
798 if (rb_obj_is_kind_of(self, rb_cData)) OBJ_FREEZE(self);
799 RB_GC_GUARD(values);
800 return Qnil;
801}
802
803static VALUE *
804struct_heap_alloc(VALUE st, size_t len)
805{
806 return ALLOC_N(VALUE, len);
807}
808
809static VALUE
810struct_alloc(VALUE klass)
811{
812 long n = num_members(klass);
813 size_t embedded_size = offsetof(struct RStruct, as.ary) + (sizeof(VALUE) * n);
814 if (RCLASS_MAX_IV_COUNT(klass) > 0) {
815 embedded_size += sizeof(VALUE);
816 }
817
819
820 if (n > 0 && rb_gc_size_allocatable_p(embedded_size)) {
821 flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
822
823 NEWOBJ_OF(st, struct RStruct, klass, flags, embedded_size, 0);
824 if (RCLASS_MAX_IV_COUNT(klass) == 0 && embedded_size == rb_gc_obj_slot_size((VALUE)st)) {
825 FL_SET_RAW((VALUE)st, RSTRUCT_GEN_FIELDS);
826 }
827 else {
828 RSTRUCT_SET_FIELDS_OBJ((VALUE)st, 0);
829 }
830 rb_mem_clear((VALUE *)st->as.ary, n);
831
832 return (VALUE)st;
833 }
834 else {
835 NEWOBJ_OF(st, struct RStruct, klass, flags, sizeof(struct RStruct), 0);
836
837 st->as.heap.ptr = NULL;
838 st->as.heap.fields_obj = 0;
839 st->as.heap.len = 0;
840
841 st->as.heap.ptr = struct_heap_alloc((VALUE)st, n);
842 rb_mem_clear((VALUE *)st->as.heap.ptr, n);
843 st->as.heap.len = n;
844
845 return (VALUE)st;
846 }
847}
848
849VALUE
851{
852 return rb_class_new_instance(RARRAY_LENINT(values), RARRAY_CONST_PTR(values), klass);
853}
854
855VALUE
857{
858 VALUE tmpargs[16], *mem = tmpargs;
859 int size, i;
860 va_list args;
861
862 size = rb_long2int(num_members(klass));
863 if (size > numberof(tmpargs)) {
864 tmpargs[0] = rb_ary_hidden_new(size);
865 mem = RARRAY_PTR(tmpargs[0]);
866 }
867 va_start(args, klass);
868 for (i=0; i<size; i++) {
869 mem[i] = va_arg(args, VALUE);
870 }
871 va_end(args);
872
873 return rb_class_new_instance(size, mem, klass);
874}
875
876static VALUE
877struct_enum_size(VALUE s, VALUE args, VALUE eobj)
878{
879 return rb_struct_size(s);
880}
881
882/*
883 * call-seq:
884 * each {|value| ... } -> self
885 * each -> enumerator
886 *
887 * Calls the given block with the value of each member; returns +self+:
888 *
889 * Customer = Struct.new(:name, :address, :zip)
890 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
891 * joe.each {|value| p value }
892 *
893 * Output:
894 *
895 * "Joe Smith"
896 * "123 Maple, Anytown NC"
897 * 12345
898 *
899 * Returns an Enumerator if no block is given.
900 *
901 * Related: #each_pair.
902 */
903
904static VALUE
905rb_struct_each(VALUE s)
906{
907 long i;
908
909 RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
910 for (i=0; i<RSTRUCT_LEN(s); i++) {
911 rb_yield(RSTRUCT_GET(s, i));
912 }
913 return s;
914}
915
916/*
917 * call-seq:
918 * each_pair {|(name, value)| ... } -> self
919 * each_pair -> enumerator
920 *
921 * Calls the given block with each member name/value pair; returns +self+:
922 *
923 * Customer = Struct.new(:name, :address, :zip) # => Customer
924 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
925 * joe.each_pair {|(name, value)| p "#{name} => #{value}" }
926 *
927 * Output:
928 *
929 * "name => Joe Smith"
930 * "address => 123 Maple, Anytown NC"
931 * "zip => 12345"
932 *
933 * Returns an Enumerator if no block is given.
934 *
935 * Related: #each.
936 *
937 */
938
939static VALUE
940rb_struct_each_pair(VALUE s)
941{
942 VALUE members;
943 long i;
944
945 RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
946 members = rb_struct_members(s);
947 if (rb_block_pair_yield_optimizable()) {
948 for (i=0; i<RSTRUCT_LEN(s); i++) {
949 VALUE key = rb_ary_entry(members, i);
950 VALUE value = RSTRUCT_GET(s, i);
951 rb_yield_values(2, key, value);
952 }
953 }
954 else {
955 for (i=0; i<RSTRUCT_LEN(s); i++) {
956 VALUE key = rb_ary_entry(members, i);
957 VALUE value = RSTRUCT_GET(s, i);
958 rb_yield(rb_assoc_new(key, value));
959 }
960 }
961 return s;
962}
963
964static VALUE
965inspect_struct(VALUE s, VALUE prefix, int recur)
966{
967 VALUE cname = rb_class_path(rb_obj_class(s));
968 VALUE members;
969 VALUE str = prefix;
970 long i, len;
971 char first = RSTRING_PTR(cname)[0];
972
973 if (recur || first != '#') {
974 rb_str_append(str, cname);
975 }
976 if (recur) {
977 return rb_str_cat2(str, ":...>");
978 }
979
980 members = rb_struct_members(s);
981 len = RSTRUCT_LEN(s);
982
983 for (i=0; i<len; i++) {
984 VALUE slot;
985 ID id;
986
987 if (i > 0) {
988 rb_str_cat2(str, ", ");
989 }
990 else if (first != '#') {
991 rb_str_cat2(str, " ");
992 }
993 slot = RARRAY_AREF(members, i);
994 id = SYM2ID(slot);
995 if (rb_is_local_id(id) || rb_is_const_id(id)) {
996 rb_str_append(str, rb_id2str(id));
997 }
998 else {
999 rb_str_append(str, rb_inspect(slot));
1000 }
1001 rb_str_cat2(str, "=");
1002 rb_str_append(str, rb_inspect(RSTRUCT_GET(s, i)));
1003 }
1004 rb_str_cat2(str, ">");
1005
1006 return str;
1007}
1008
1009/*
1010 * call-seq:
1011 * inspect -> string
1012 *
1013 * Returns a string representation of +self+:
1014 *
1015 * Customer = Struct.new(:name, :address, :zip) # => Customer
1016 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1017 * joe.inspect # => "#<struct Customer name=\"Joe Smith\", address=\"123 Maple, Anytown NC\", zip=12345>"
1018 *
1019 */
1020
1021static VALUE
1022rb_struct_inspect(VALUE s)
1023{
1024 return rb_exec_recursive(inspect_struct, s, rb_str_new2("#<struct "));
1025}
1026
1027/*
1028 * call-seq:
1029 * to_a -> array
1030 *
1031 * Returns the values in +self+ as an array:
1032 *
1033 * Customer = Struct.new(:name, :address, :zip)
1034 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1035 * joe.to_a # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1036 *
1037 * Related: #members.
1038 */
1039
1040static VALUE
1041rb_struct_to_a(VALUE s)
1042{
1043 return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
1044}
1045
1046/*
1047 * call-seq:
1048 * to_h -> hash
1049 * to_h {|name, value| ... } -> hash
1050 *
1051 * Returns a hash containing the name and value for each member:
1052 *
1053 * Customer = Struct.new(:name, :address, :zip)
1054 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1055 * h = joe.to_h
1056 * h # => {:name=>"Joe Smith", :address=>"123 Maple, Anytown NC", :zip=>12345}
1057 *
1058 * If a block is given, it is called with each name/value pair;
1059 * the block should return a 2-element array whose elements will become
1060 * a key/value pair in the returned hash:
1061 *
1062 * h = joe.to_h{|name, value| [name.upcase, value.to_s.upcase]}
1063 * h # => {:NAME=>"JOE SMITH", :ADDRESS=>"123 MAPLE, ANYTOWN NC", :ZIP=>"12345"}
1064 *
1065 * Raises ArgumentError if the block returns an inappropriate value.
1066 *
1067 */
1068
1069static VALUE
1070rb_struct_to_h(VALUE s)
1071{
1072 VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
1073 VALUE members = rb_struct_members(s);
1074 long i;
1075 int block_given = rb_block_given_p();
1076
1077 for (i=0; i<RSTRUCT_LEN(s); i++) {
1078 VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET(s, i);
1079 if (block_given)
1080 rb_hash_set_pair(h, rb_yield_values(2, k, v));
1081 else
1082 rb_hash_aset(h, k, v);
1083 }
1084 return h;
1085}
1086
1087/*
1088 * call-seq:
1089 * deconstruct_keys(array_of_names) -> hash
1090 *
1091 * Returns a hash of the name/value pairs for the given member names.
1092 *
1093 * Customer = Struct.new(:name, :address, :zip)
1094 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1095 * h = joe.deconstruct_keys([:zip, :address])
1096 * h # => {:zip=>12345, :address=>"123 Maple, Anytown NC"}
1097 *
1098 * Returns all names and values if +array_of_names+ is +nil+:
1099 *
1100 * h = joe.deconstruct_keys(nil)
1101 * h # => {:name=>"Joseph Smith, Jr.", :address=>"123 Maple, Anytown NC", :zip=>12345}
1102 *
1103 */
1104static VALUE
1105rb_struct_deconstruct_keys(VALUE s, VALUE keys)
1106{
1107 VALUE h;
1108 long i;
1109
1110 if (NIL_P(keys)) {
1111 return rb_struct_to_h(s);
1112 }
1113 if (UNLIKELY(!RB_TYPE_P(keys, T_ARRAY))) {
1114 rb_raise(rb_eTypeError,
1115 "wrong argument type %"PRIsVALUE" (expected Array or nil)",
1116 rb_obj_class(keys));
1117
1118 }
1119 if (RSTRUCT_LEN(s) < RARRAY_LEN(keys)) {
1120 return rb_hash_new_with_size(0);
1121 }
1122 h = rb_hash_new_with_size(RARRAY_LEN(keys));
1123 for (i=0; i<RARRAY_LEN(keys); i++) {
1124 VALUE key = RARRAY_AREF(keys, i);
1125 int i = rb_struct_pos(s, &key);
1126 if (i < 0) {
1127 return h;
1128 }
1129 rb_hash_aset(h, key, RSTRUCT_GET(s, i));
1130 }
1131 return h;
1132}
1133
1134/* :nodoc: */
1135VALUE
1136rb_struct_init_copy(VALUE copy, VALUE s)
1137{
1138 long i, len;
1139
1140 if (!OBJ_INIT_COPY(copy, s)) return copy;
1141 if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
1142 rb_raise(rb_eTypeError, "struct size mismatch");
1143 }
1144
1145 for (i=0, len=RSTRUCT_LEN(copy); i<len; i++) {
1146 RSTRUCT_SET(copy, i, RSTRUCT_GET(s, i));
1147 }
1148
1149 return copy;
1150}
1151
1152static int
1153rb_struct_pos(VALUE s, VALUE *name)
1154{
1155 long i;
1156 VALUE idx = *name;
1157
1158 if (SYMBOL_P(idx)) {
1159 return struct_member_pos(s, idx);
1160 }
1161 else if (RB_TYPE_P(idx, T_STRING)) {
1162 idx = rb_check_symbol(name);
1163 if (NIL_P(idx)) return -1;
1164 return struct_member_pos(s, idx);
1165 }
1166 else {
1167 long len;
1168 i = NUM2LONG(idx);
1169 len = RSTRUCT_LEN(s);
1170 if (i < 0) {
1171 if (i + len < 0) {
1172 *name = LONG2FIX(i);
1173 return -1;
1174 }
1175 i += len;
1176 }
1177 else if (len <= i) {
1178 *name = LONG2FIX(i);
1179 return -1;
1180 }
1181 return (int)i;
1182 }
1183}
1184
1185static void
1186invalid_struct_pos(VALUE s, VALUE idx)
1187{
1188 if (FIXNUM_P(idx)) {
1189 long i = FIX2INT(idx), len = RSTRUCT_LEN(s);
1190 if (i < 0) {
1191 rb_raise(rb_eIndexError, "offset %ld too small for struct(size:%ld)",
1192 i, len);
1193 }
1194 else {
1195 rb_raise(rb_eIndexError, "offset %ld too large for struct(size:%ld)",
1196 i, len);
1197 }
1198 }
1199 else {
1200 rb_name_err_raise("no member '%1$s' in struct", s, idx);
1201 }
1202}
1203
1204/*
1205 * call-seq:
1206 * struct[name] -> object
1207 * struct[n] -> object
1208 *
1209 * Returns a value from +self+.
1210 *
1211 * With symbol or string argument +name+ given, returns the value for the named member:
1212 *
1213 * Customer = Struct.new(:name, :address, :zip)
1214 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1215 * joe[:zip] # => 12345
1216 *
1217 * Raises NameError if +name+ is not the name of a member.
1218 *
1219 * With integer argument +n+ given, returns <tt>self.values[n]</tt>
1220 * if +n+ is in range;
1221 * see Array@Array+Indexes:
1222 *
1223 * joe[2] # => 12345
1224 * joe[-2] # => "123 Maple, Anytown NC"
1225 *
1226 * Raises IndexError if +n+ is out of range.
1227 *
1228 */
1229
1230VALUE
1232{
1233 int i = rb_struct_pos(s, &idx);
1234 if (i < 0) invalid_struct_pos(s, idx);
1235 return RSTRUCT_GET(s, i);
1236}
1237
1238/*
1239 * call-seq:
1240 * struct[name] = value -> value
1241 * struct[n] = value -> value
1242 *
1243 * Assigns a value to a member.
1244 *
1245 * With symbol or string argument +name+ given, assigns the given +value+
1246 * to the named member; returns +value+:
1247 *
1248 * Customer = Struct.new(:name, :address, :zip)
1249 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1250 * joe[:zip] = 54321 # => 54321
1251 * joe # => #<struct Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=54321>
1252 *
1253 * Raises NameError if +name+ is not the name of a member.
1254 *
1255 * With integer argument +n+ given, assigns the given +value+
1256 * to the +n+-th member if +n+ is in range;
1257 * see Array@Array+Indexes:
1258 *
1259 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1260 * joe[2] = 54321 # => 54321
1261 * joe[-3] = 'Joseph Smith' # => "Joseph Smith"
1262 * joe # => #<struct Customer name="Joseph Smith", address="123 Maple, Anytown NC", zip=54321>
1263 *
1264 * Raises IndexError if +n+ is out of range.
1265 *
1266 */
1267
1268VALUE
1270{
1271 int i = rb_struct_pos(s, &idx);
1272 if (i < 0) invalid_struct_pos(s, idx);
1273 rb_struct_modify(s);
1274 RSTRUCT_SET(s, i, val);
1275 return val;
1276}
1277
1278FUNC_MINIMIZED(VALUE rb_struct_lookup(VALUE s, VALUE idx));
1279NOINLINE(static VALUE rb_struct_lookup_default(VALUE s, VALUE idx, VALUE notfound));
1280
1281VALUE
1282rb_struct_lookup(VALUE s, VALUE idx)
1283{
1284 return rb_struct_lookup_default(s, idx, Qnil);
1285}
1286
1287static VALUE
1288rb_struct_lookup_default(VALUE s, VALUE idx, VALUE notfound)
1289{
1290 int i = rb_struct_pos(s, &idx);
1291 if (i < 0) return notfound;
1292 return RSTRUCT_GET(s, i);
1293}
1294
1295static VALUE
1296struct_entry(VALUE s, long n)
1297{
1298 return rb_struct_aref(s, LONG2NUM(n));
1299}
1300
1301/*
1302 * call-seq:
1303 * values_at(*integers) -> array
1304 * values_at(integer_range) -> array
1305 *
1306 * Returns an array of values from +self+.
1307 *
1308 * With integer arguments +integers+ given,
1309 * returns an array containing each value given by one of +integers+:
1310 *
1311 * Customer = Struct.new(:name, :address, :zip)
1312 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1313 * joe.values_at(0, 2) # => ["Joe Smith", 12345]
1314 * joe.values_at(2, 0) # => [12345, "Joe Smith"]
1315 * joe.values_at(2, 1, 0) # => [12345, "123 Maple, Anytown NC", "Joe Smith"]
1316 * joe.values_at(0, -3) # => ["Joe Smith", "Joe Smith"]
1317 *
1318 * Raises IndexError if any of +integers+ is out of range;
1319 * see Array@Array+Indexes.
1320 *
1321 * With integer range argument +integer_range+ given,
1322 * returns an array containing each value given by the elements of the range;
1323 * fills with +nil+ values for range elements larger than the structure:
1324 *
1325 * joe.values_at(0..2)
1326 * # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1327 * joe.values_at(-3..-1)
1328 * # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1329 * joe.values_at(1..4) # => ["123 Maple, Anytown NC", 12345, nil, nil]
1330 *
1331 * Raises RangeError if any element of the range is negative and out of range;
1332 * see Array@Array+Indexes.
1333 *
1334 */
1335
1336static VALUE
1337rb_struct_values_at(int argc, VALUE *argv, VALUE s)
1338{
1339 return rb_get_values_at(s, RSTRUCT_LEN(s), argc, argv, struct_entry);
1340}
1341
1342/*
1343 * call-seq:
1344 * select {|value| ... } -> array
1345 * select -> enumerator
1346 *
1347 * With a block given, returns an array of values from +self+
1348 * for which the block returns a truthy value:
1349 *
1350 * Customer = Struct.new(:name, :address, :zip)
1351 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1352 * a = joe.select {|value| value.is_a?(String) }
1353 * a # => ["Joe Smith", "123 Maple, Anytown NC"]
1354 * a = joe.select {|value| value.is_a?(Integer) }
1355 * a # => [12345]
1356 *
1357 * With no block given, returns an Enumerator.
1358 */
1359
1360static VALUE
1361rb_struct_select(int argc, VALUE *argv, VALUE s)
1362{
1363 VALUE result;
1364 long i;
1365
1366 rb_check_arity(argc, 0, 0);
1367 RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
1368 result = rb_ary_new();
1369 for (i = 0; i < RSTRUCT_LEN(s); i++) {
1370 if (RTEST(rb_yield(RSTRUCT_GET(s, i)))) {
1371 rb_ary_push(result, RSTRUCT_GET(s, i));
1372 }
1373 }
1374
1375 return result;
1376}
1377
1378static VALUE
1379recursive_equal(VALUE s, VALUE s2, int recur)
1380{
1381 long i, len;
1382
1383 if (recur) return Qtrue; /* Subtle! */
1384 len = RSTRUCT_LEN(s);
1385 for (i=0; i<len; i++) {
1386 if (!rb_equal(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
1387 }
1388 return Qtrue;
1389}
1390
1391
1392/*
1393 * call-seq:
1394 * self == other -> true or false
1395 *
1396 * Returns +true+ if and only if the following are true; otherwise returns +false+:
1397 *
1398 * - <tt>other.class == self.class</tt>.
1399 * - For each member name +name+, <tt>other.name == self.name</tt>.
1400 *
1401 * Examples:
1402 *
1403 * Customer = Struct.new(:name, :address, :zip)
1404 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1405 * joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1406 * joe_jr == joe # => true
1407 * joe_jr[:name] = 'Joe Smith, Jr.'
1408 * # => "Joe Smith, Jr."
1409 * joe_jr == joe # => false
1410 */
1411
1412static VALUE
1413rb_struct_equal(VALUE s, VALUE s2)
1414{
1415 if (s == s2) return Qtrue;
1416 if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
1417 if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
1418 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1419 rb_bug("inconsistent struct"); /* should never happen */
1420 }
1421
1422 return rb_exec_recursive_paired(recursive_equal, s, s2, s2);
1423}
1424
1425/*
1426 * call-seq:
1427 * hash -> integer
1428 *
1429 * Returns the integer hash value for +self+.
1430 *
1431 * Two structs of the same class and with the same content
1432 * will have the same hash code (and will compare using Struct#eql?):
1433 *
1434 * Customer = Struct.new(:name, :address, :zip)
1435 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1436 * joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1437 * joe.hash == joe_jr.hash # => true
1438 * joe_jr[:name] = 'Joe Smith, Jr.'
1439 * joe.hash == joe_jr.hash # => false
1440 *
1441 * Related: Object#hash.
1442 */
1443
1444static VALUE
1445rb_struct_hash(VALUE s)
1446{
1447 long i, len;
1448 st_index_t h;
1449 VALUE n;
1450
1451 h = rb_hash_start(rb_hash(rb_obj_class(s)));
1452 len = RSTRUCT_LEN(s);
1453 for (i = 0; i < len; i++) {
1454 n = rb_hash(RSTRUCT_GET(s, i));
1455 h = rb_hash_uint(h, NUM2LONG(n));
1456 }
1457 h = rb_hash_end(h);
1458 return ST2FIX(h);
1459}
1460
1461static VALUE
1462recursive_eql(VALUE s, VALUE s2, int recur)
1463{
1464 long i, len;
1465
1466 if (recur) return Qtrue; /* Subtle! */
1467 len = RSTRUCT_LEN(s);
1468 for (i=0; i<len; i++) {
1469 if (!rb_eql(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
1470 }
1471 return Qtrue;
1472}
1473
1474/*
1475 * call-seq:
1476 * eql?(other) -> true or false
1477 *
1478 * Returns +true+ if and only if the following are true; otherwise returns +false+:
1479 *
1480 * - <tt>other.class == self.class</tt>.
1481 * - For each member name +name+, <tt>other.name.eql?(self.name)</tt>.
1482 *
1483 * Customer = Struct.new(:name, :address, :zip)
1484 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1485 * joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1486 * joe_jr.eql?(joe) # => true
1487 * joe_jr[:name] = 'Joe Smith, Jr.'
1488 * joe_jr.eql?(joe) # => false
1489 *
1490 * Related: Object#==.
1491 */
1492
1493static VALUE
1494rb_struct_eql(VALUE s, VALUE s2)
1495{
1496 if (s == s2) return Qtrue;
1497 if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
1498 if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
1499 if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1500 rb_bug("inconsistent struct"); /* should never happen */
1501 }
1502
1503 return rb_exec_recursive_paired(recursive_eql, s, s2, s2);
1504}
1505
1506/*
1507 * call-seq:
1508 * size -> integer
1509 *
1510 * Returns the number of members.
1511 *
1512 * Customer = Struct.new(:name, :address, :zip)
1513 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1514 * joe.size #=> 3
1515 *
1516 */
1517
1518VALUE
1520{
1521 return LONG2FIX(RSTRUCT_LEN(s));
1522}
1523
1524/*
1525 * call-seq:
1526 * dig(name, *identifiers) -> object
1527 * dig(n, *identifiers) -> object
1528 *
1529 * Finds and returns an object among nested objects.
1530 * The nested objects may be instances of various classes.
1531 * See {Dig Methods}[rdoc-ref:dig_methods.rdoc].
1532 *
1533 *
1534 * Given symbol or string argument +name+,
1535 * returns the object that is specified by +name+ and +identifiers+:
1536 *
1537 * Foo = Struct.new(:a)
1538 * f = Foo.new(Foo.new({b: [1, 2, 3]}))
1539 * f.dig(:a) # => #<struct Foo a={:b=>[1, 2, 3]}>
1540 * f.dig(:a, :a) # => {:b=>[1, 2, 3]}
1541 * f.dig(:a, :a, :b) # => [1, 2, 3]
1542 * f.dig(:a, :a, :b, 0) # => 1
1543 * f.dig(:b, 0) # => nil
1544 *
1545 * Given integer argument +n+,
1546 * returns the object that is specified by +n+ and +identifiers+:
1547 *
1548 * f.dig(0) # => #<struct Foo a={:b=>[1, 2, 3]}>
1549 * f.dig(0, 0) # => {:b=>[1, 2, 3]}
1550 * f.dig(0, 0, :b) # => [1, 2, 3]
1551 * f.dig(0, 0, :b, 0) # => 1
1552 * f.dig(:b, 0) # => nil
1553 *
1554 */
1555
1556static VALUE
1557rb_struct_dig(int argc, VALUE *argv, VALUE self)
1558{
1560 self = rb_struct_lookup(self, *argv);
1561 if (!--argc) return self;
1562 ++argv;
1563 return rb_obj_dig(argc, argv, self, Qnil);
1564}
1565
1566/*
1567 * Document-class: Data
1568 *
1569 * Class \Data provides a convenient way to define simple classes
1570 * for value-alike objects.
1571 *
1572 * The simplest example of usage:
1573 *
1574 * Measure = Data.define(:amount, :unit)
1575 *
1576 * # Positional arguments constructor is provided
1577 * distance = Measure.new(100, 'km')
1578 * #=> #<data Measure amount=100, unit="km">
1579 *
1580 * # Keyword arguments constructor is provided
1581 * weight = Measure.new(amount: 50, unit: 'kg')
1582 * #=> #<data Measure amount=50, unit="kg">
1583 *
1584 * # Alternative form to construct an object:
1585 * speed = Measure[10, 'mPh']
1586 * #=> #<data Measure amount=10, unit="mPh">
1587 *
1588 * # Works with keyword arguments, too:
1589 * area = Measure[amount: 1.5, unit: 'm^2']
1590 * #=> #<data Measure amount=1.5, unit="m^2">
1591 *
1592 * # Argument accessors are provided:
1593 * distance.amount #=> 100
1594 * distance.unit #=> "km"
1595 *
1596 * Constructed object also has a reasonable definitions of #==
1597 * operator, #to_h hash conversion, and #deconstruct / #deconstruct_keys
1598 * to be used in pattern matching.
1599 *
1600 * ::define method accepts an optional block and evaluates it in
1601 * the context of the newly defined class. That allows to define
1602 * additional methods:
1603 *
1604 * Measure = Data.define(:amount, :unit) do
1605 * def <=>(other)
1606 * return unless other.is_a?(self.class) && other.unit == unit
1607 * amount <=> other.amount
1608 * end
1609 *
1610 * include Comparable
1611 * end
1612 *
1613 * Measure[3, 'm'] < Measure[5, 'm'] #=> true
1614 * Measure[3, 'm'] < Measure[5, 'kg']
1615 * # comparison of Measure with Measure failed (ArgumentError)
1616 *
1617 * Data provides no member writers, or enumerators: it is meant
1618 * to be a storage for immutable atomic values. But note that
1619 * if some of data members is of a mutable class, Data does no additional
1620 * immutability enforcement:
1621 *
1622 * Event = Data.define(:time, :weekdays)
1623 * event = Event.new('18:00', %w[Tue Wed Fri])
1624 * #=> #<data Event time="18:00", weekdays=["Tue", "Wed", "Fri"]>
1625 *
1626 * # There is no #time= or #weekdays= accessors, but changes are
1627 * # still possible:
1628 * event.weekdays << 'Sat'
1629 * event
1630 * #=> #<data Event time="18:00", weekdays=["Tue", "Wed", "Fri", "Sat"]>
1631 *
1632 * See also Struct, which is a similar concept, but has more
1633 * container-alike API, allowing to change contents of the object
1634 * and enumerate it.
1635 */
1636
1637/*
1638 * call-seq:
1639 * define(*symbols) -> class
1640 *
1641 * Defines a new \Data class.
1642 *
1643 * measure = Data.define(:amount, :unit)
1644 * #=> #<Class:0x00007f70c6868498>
1645 * measure.new(1, 'km')
1646 * #=> #<data amount=1, unit="km">
1647 *
1648 * # It you store the new class in the constant, it will
1649 * # affect #inspect and will be more natural to use:
1650 * Measure = Data.define(:amount, :unit)
1651 * #=> Measure
1652 * Measure.new(1, 'km')
1653 * #=> #<data Measure amount=1, unit="km">
1654 *
1655 *
1656 * Note that member-less \Data is acceptable and might be a useful technique
1657 * for defining several homogeneous data classes, like
1658 *
1659 * class HTTPFetcher
1660 * Response = Data.define(:body)
1661 * NotFound = Data.define
1662 * # ... implementation
1663 * end
1664 *
1665 * Now, different kinds of responses from +HTTPFetcher+ would have consistent
1666 * representation:
1667 *
1668 * #<data HTTPFetcher::Response body="<html...">
1669 * #<data HTTPFetcher::NotFound>
1670 *
1671 * And are convenient to use in pattern matching:
1672 *
1673 * case fetcher.get(url)
1674 * in HTTPFetcher::Response(body)
1675 * # process body variable
1676 * in HTTPFetcher::NotFound
1677 * # handle not found case
1678 * end
1679 */
1680
1681static VALUE
1682rb_data_s_def(int argc, VALUE *argv, VALUE klass)
1683{
1684 VALUE rest;
1685 long i;
1686 VALUE data_class;
1687
1688 rest = rb_ident_hash_new();
1689 RBASIC_CLEAR_CLASS(rest);
1690 for (i=0; i<argc; i++) {
1691 VALUE mem = rb_to_symbol(argv[i]);
1692 if (rb_is_attrset_sym(mem)) {
1693 rb_raise(rb_eArgError, "invalid data member: %"PRIsVALUE, mem);
1694 }
1695 if (RTEST(rb_hash_has_key(rest, mem))) {
1696 rb_raise(rb_eArgError, "duplicate member: %"PRIsVALUE, mem);
1697 }
1698 rb_hash_aset(rest, mem, Qtrue);
1699 }
1700 rest = rb_hash_keys(rest);
1701 RBASIC_CLEAR_CLASS(rest);
1702 OBJ_FREEZE(rest);
1703 data_class = anonymous_struct(klass);
1704 setup_data(data_class, rest);
1705 if (rb_block_given_p()) {
1706 rb_mod_module_eval(0, 0, data_class);
1707 }
1708
1709 return data_class;
1710}
1711
1712VALUE
1714{
1715 va_list ar;
1716 VALUE ary;
1717 va_start(ar, super);
1718 ary = struct_make_members_list(ar);
1719 va_end(ar);
1720 if (!super) super = rb_cData;
1721 VALUE klass = setup_data(anonymous_struct(super), ary);
1722 rb_vm_register_global_object(klass);
1723 return klass;
1724}
1725
1726/*
1727 * call-seq:
1728 * DataClass::members -> array_of_symbols
1729 *
1730 * Returns an array of member names of the data class:
1731 *
1732 * Measure = Data.define(:amount, :unit)
1733 * Measure.members # => [:amount, :unit]
1734 *
1735 */
1736
1737#define rb_data_s_members_m rb_struct_s_members_m
1738
1739
1740/*
1741 * call-seq:
1742 * new(*args) -> instance
1743 * new(**kwargs) -> instance
1744 * ::[](*args) -> instance
1745 * ::[](**kwargs) -> instance
1746 *
1747 * Constructors for classes defined with ::define accept both positional and
1748 * keyword arguments.
1749 *
1750 * Measure = Data.define(:amount, :unit)
1751 *
1752 * Measure.new(1, 'km')
1753 * #=> #<data Measure amount=1, unit="km">
1754 * Measure.new(amount: 1, unit: 'km')
1755 * #=> #<data Measure amount=1, unit="km">
1756 *
1757 * # Alternative shorter initialization with []
1758 * Measure[1, 'km']
1759 * #=> #<data Measure amount=1, unit="km">
1760 * Measure[amount: 1, unit: 'km']
1761 * #=> #<data Measure amount=1, unit="km">
1762 *
1763 * All arguments are mandatory (unlike Struct), and converted to keyword arguments:
1764 *
1765 * Measure.new(amount: 1)
1766 * # in `initialize': missing keyword: :unit (ArgumentError)
1767 *
1768 * Measure.new(1)
1769 * # in `initialize': missing keyword: :unit (ArgumentError)
1770 *
1771 * Note that <tt>Measure#initialize</tt> always receives keyword arguments, and that
1772 * mandatory arguments are checked in +initialize+, not in +new+. This can be
1773 * important for redefining initialize in order to convert arguments or provide
1774 * defaults:
1775 *
1776 * Measure = Data.define(:amount, :unit)
1777 * class Measure
1778 * NONE = Data.define
1779 *
1780 * def initialize(amount:, unit: NONE.new)
1781 * super(amount: Float(amount), unit:)
1782 * end
1783 * end
1784 *
1785 * Measure.new('10', 'km') # => #<data Measure amount=10.0, unit="km">
1786 * Measure.new(10_000) # => #<data Measure amount=10000.0, unit=#<data Measure::NONE>>
1787 *
1788 */
1789
1790static VALUE
1791rb_data_initialize_m(int argc, const VALUE *argv, VALUE self)
1792{
1793 VALUE klass = rb_obj_class(self);
1794 rb_struct_modify(self);
1795 VALUE members = struct_ivar_get(klass, id_members);
1796 size_t num_members = RARRAY_LEN(members);
1797
1798 if (argc == 0) {
1799 if (num_members > 0) {
1800 rb_exc_raise(rb_keyword_error_new("missing", members));
1801 }
1802 return Qnil;
1803 }
1804 if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
1805 rb_error_arity(argc, 0, 0);
1806 }
1807
1808 if (RHASH_SIZE(argv[0]) < num_members) {
1809 VALUE missing = rb_ary_diff(members, rb_hash_keys(argv[0]));
1810 rb_exc_raise(rb_keyword_error_new("missing", missing));
1811 }
1812
1813 struct struct_hash_set_arg arg;
1814 rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self), num_members);
1815 arg.self = self;
1816 arg.unknown_keywords = Qnil;
1817 rb_hash_foreach(argv[0], struct_hash_set_i, (VALUE)&arg);
1818 // Freeze early before potentially raising, so that we don't leave an
1819 // unfrozen copy on the heap, which could get exposed via ObjectSpace.
1820 OBJ_FREEZE(self);
1821 if (arg.unknown_keywords != Qnil) {
1822 rb_exc_raise(rb_keyword_error_new("unknown", arg.unknown_keywords));
1823 }
1824 return Qnil;
1825}
1826
1827/* :nodoc: */
1828static VALUE
1829rb_data_init_copy(VALUE copy, VALUE s)
1830{
1831 copy = rb_struct_init_copy(copy, s);
1832 RB_OBJ_FREEZE(copy);
1833 return copy;
1834}
1835
1836/*
1837 * call-seq:
1838 * with(**kwargs) -> instance
1839 *
1840 * Returns a shallow copy of +self+ --- the instance variables of
1841 * +self+ are copied, but not the objects they reference.
1842 *
1843 * If the method is supplied any keyword arguments, the copy will
1844 * be created with the respective field values updated to use the
1845 * supplied keyword argument values. Note that it is an error to
1846 * supply a keyword that the Data class does not have as a member.
1847 *
1848 * Point = Data.define(:x, :y)
1849 *
1850 * origin = Point.new(x: 0, y: 0)
1851 *
1852 * up = origin.with(x: 1)
1853 * right = origin.with(y: 1)
1854 * up_and_right = up.with(y: 1)
1855 *
1856 * p origin # #<data Point x=0, y=0>
1857 * p up # #<data Point x=1, y=0>
1858 * p right # #<data Point x=0, y=1>
1859 * p up_and_right # #<data Point x=1, y=1>
1860 *
1861 * out = origin.with(z: 1) # ArgumentError: unknown keyword: :z
1862 * some_point = origin.with(1, 2) # ArgumentError: expected keyword arguments, got positional arguments
1863 *
1864 */
1865
1866static VALUE
1867rb_data_with(int argc, const VALUE *argv, VALUE self)
1868{
1869 VALUE kwargs;
1870 rb_scan_args(argc, argv, "0:", &kwargs);
1871 if (NIL_P(kwargs)) {
1872 return self;
1873 }
1874
1875 VALUE h = rb_struct_to_h(self);
1876 rb_hash_update_by(h, kwargs, 0);
1877 return rb_class_new_instance_kw(1, &h, rb_obj_class(self), TRUE);
1878}
1879
1880/*
1881 * call-seq:
1882 * inspect -> string
1883 * to_s -> string
1884 *
1885 * Returns a string representation of +self+:
1886 *
1887 * Measure = Data.define(:amount, :unit)
1888 *
1889 * distance = Measure[10, 'km']
1890 *
1891 * p distance # uses #inspect underneath
1892 * #<data Measure amount=10, unit="km">
1893 *
1894 * puts distance # uses #to_s underneath, same representation
1895 * #<data Measure amount=10, unit="km">
1896 *
1897 */
1898
1899static VALUE
1900rb_data_inspect(VALUE s)
1901{
1902 return rb_exec_recursive(inspect_struct, s, rb_str_new2("#<data "));
1903}
1904
1905/*
1906 * call-seq:
1907 * self == other -> true or false
1908 *
1909 * Returns +true+ if +other+ is the same class as +self+, and all members are
1910 * equal.
1911 *
1912 * Examples:
1913 *
1914 * Measure = Data.define(:amount, :unit)
1915 *
1916 * Measure[1, 'km'] == Measure[1, 'km'] #=> true
1917 * Measure[1, 'km'] == Measure[2, 'km'] #=> false
1918 * Measure[1, 'km'] == Measure[1, 'm'] #=> false
1919 *
1920 * Measurement = Data.define(:amount, :unit)
1921 * # Even though Measurement and Measure have the same "shape"
1922 * # their instances are never equal
1923 * Measure[1, 'km'] == Measurement[1, 'km'] #=> false
1924 */
1925
1926#define rb_data_equal rb_struct_equal
1927
1928/*
1929 * call-seq:
1930 * self.eql?(other) -> true or false
1931 *
1932 * Equality check that is used when two items of data are keys of a Hash.
1933 *
1934 * The subtle difference with #== is that members are also compared with their
1935 * #eql? method, which might be important in some cases:
1936 *
1937 * Measure = Data.define(:amount, :unit)
1938 *
1939 * Measure[1, 'km'] == Measure[1.0, 'km'] #=> true, they are equal as values
1940 * # ...but...
1941 * Measure[1, 'km'].eql? Measure[1.0, 'km'] #=> false, they represent different hash keys
1942 *
1943 * See also Object#eql? for further explanations of the method usage.
1944 */
1945
1946#define rb_data_eql rb_struct_eql
1947
1948/*
1949 * call-seq:
1950 * hash -> integer
1951 *
1952 * Redefines Object#hash (used to distinguish objects as Hash keys) so that
1953 * data objects of the same class with same content would have the same +hash+
1954 * value, and represented the same Hash key.
1955 *
1956 * Measure = Data.define(:amount, :unit)
1957 *
1958 * Measure[1, 'km'].hash == Measure[1, 'km'].hash #=> true
1959 * Measure[1, 'km'].hash == Measure[10, 'km'].hash #=> false
1960 * Measure[1, 'km'].hash == Measure[1, 'm'].hash #=> false
1961 * Measure[1, 'km'].hash == Measure[1.0, 'km'].hash #=> false
1962 *
1963 * # Structurally similar data class, but shouldn't be considered
1964 * # the same hash key
1965 * Measurement = Data.define(:amount, :unit)
1966 *
1967 * Measure[1, 'km'].hash == Measurement[1, 'km'].hash #=> false
1968 */
1969
1970#define rb_data_hash rb_struct_hash
1971
1972/*
1973 * call-seq:
1974 * to_h -> hash
1975 * to_h {|name, value| ... } -> hash
1976 *
1977 * Returns Hash representation of the data object.
1978 *
1979 * Measure = Data.define(:amount, :unit)
1980 * distance = Measure[10, 'km']
1981 *
1982 * distance.to_h
1983 * #=> {:amount=>10, :unit=>"km"}
1984 *
1985 * Like Enumerable#to_h, if the block is provided, it is expected to
1986 * produce key-value pairs to construct a hash:
1987 *
1988 *
1989 * distance.to_h { |name, val| [name.to_s, val.to_s] }
1990 * #=> {"amount"=>"10", "unit"=>"km"}
1991 *
1992 * Note that there is a useful symmetry between #to_h and #initialize:
1993 *
1994 * distance2 = Measure.new(**distance.to_h)
1995 * #=> #<data Measure amount=10, unit="km">
1996 * distance2 == distance
1997 * #=> true
1998 */
1999
2000#define rb_data_to_h rb_struct_to_h
2001
2002/*
2003 * call-seq:
2004 * members -> array_of_symbols
2005 *
2006 * Returns the member names from +self+ as an array:
2007 *
2008 * Measure = Data.define(:amount, :unit)
2009 * distance = Measure[10, 'km']
2010 *
2011 * distance.members #=> [:amount, :unit]
2012 *
2013 */
2014
2015#define rb_data_members_m rb_struct_members_m
2016
2017/*
2018 * call-seq:
2019 * deconstruct -> array
2020 *
2021 * Returns the values in +self+ as an array, to use in pattern matching:
2022 *
2023 * Measure = Data.define(:amount, :unit)
2024 *
2025 * distance = Measure[10, 'km']
2026 * distance.deconstruct #=> [10, "km"]
2027 *
2028 * # usage
2029 * case distance
2030 * in n, 'km' # calls #deconstruct underneath
2031 * puts "It is #{n} kilometers away"
2032 * else
2033 * puts "Don't know how to handle it"
2034 * end
2035 * # prints "It is 10 kilometers away"
2036 *
2037 * Or, with checking the class, too:
2038 *
2039 * case distance
2040 * in Measure(n, 'km')
2041 * puts "It is #{n} kilometers away"
2042 * # ...
2043 * end
2044 */
2045
2046#define rb_data_deconstruct rb_struct_to_a
2047
2048/*
2049 * call-seq:
2050 * deconstruct_keys(array_of_names_or_nil) -> hash
2051 *
2052 * Returns a hash of the name/value pairs, to use in pattern matching.
2053 *
2054 * Measure = Data.define(:amount, :unit)
2055 *
2056 * distance = Measure[10, 'km']
2057 * distance.deconstruct_keys(nil) #=> {:amount=>10, :unit=>"km"}
2058 * distance.deconstruct_keys([:amount]) #=> {:amount=>10}
2059 *
2060 * # usage
2061 * case distance
2062 * in amount:, unit: 'km' # calls #deconstruct_keys underneath
2063 * puts "It is #{amount} kilometers away"
2064 * else
2065 * puts "Don't know how to handle it"
2066 * end
2067 * # prints "It is 10 kilometers away"
2068 *
2069 * Or, with checking the class, too:
2070 *
2071 * case distance
2072 * in Measure(amount:, unit: 'km')
2073 * puts "It is #{amount} kilometers away"
2074 * # ...
2075 * end
2076 */
2077
2078#define rb_data_deconstruct_keys rb_struct_deconstruct_keys
2079
2080/*
2081 * Document-class: Struct
2082 *
2083 * Class \Struct provides a convenient way to create a simple class
2084 * that can store and fetch values.
2085 *
2086 * This example creates a subclass of +Struct+, <tt>Struct::Customer</tt>;
2087 * the first argument, a string, is the name of the subclass;
2088 * the other arguments, symbols, determine the _members_ of the new subclass.
2089 *
2090 * Customer = Struct.new('Customer', :name, :address, :zip)
2091 * Customer.name # => "Struct::Customer"
2092 * Customer.class # => Class
2093 * Customer.superclass # => Struct
2094 *
2095 * Corresponding to each member are two methods, a writer and a reader,
2096 * that store and fetch values:
2097 *
2098 * methods = Customer.instance_methods false
2099 * methods # => [:zip, :address=, :zip=, :address, :name, :name=]
2100 *
2101 * An instance of the subclass may be created,
2102 * and its members assigned values, via method <tt>::new</tt>:
2103 *
2104 * joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
2105 * joe # => #<struct Struct::Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=12345>
2106 *
2107 * The member values may be managed thus:
2108 *
2109 * joe.name # => "Joe Smith"
2110 * joe.name = 'Joseph Smith'
2111 * joe.name # => "Joseph Smith"
2112 *
2113 * And thus; note that member name may be expressed as either a string or a symbol:
2114 *
2115 * joe[:name] # => "Joseph Smith"
2116 * joe[:name] = 'Joseph Smith, Jr.'
2117 * joe['name'] # => "Joseph Smith, Jr."
2118 *
2119 * See Struct::new.
2120 *
2121 * == What's Here
2122 *
2123 * First, what's elsewhere. Class \Struct:
2124 *
2125 * - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].
2126 * - Includes {module Enumerable}[rdoc-ref:Enumerable@What-27s+Here],
2127 * which provides dozens of additional methods.
2128 *
2129 * See also Data, which is a somewhat similar, but stricter concept for defining immutable
2130 * value objects.
2131 *
2132 * Here, class \Struct provides methods that are useful for:
2133 *
2134 * - {Creating a Struct Subclass}[rdoc-ref:Struct@Methods+for+Creating+a+Struct+Subclass]
2135 * - {Querying}[rdoc-ref:Struct@Methods+for+Querying]
2136 * - {Comparing}[rdoc-ref:Struct@Methods+for+Comparing]
2137 * - {Fetching}[rdoc-ref:Struct@Methods+for+Fetching]
2138 * - {Assigning}[rdoc-ref:Struct@Methods+for+Assigning]
2139 * - {Iterating}[rdoc-ref:Struct@Methods+for+Iterating]
2140 * - {Converting}[rdoc-ref:Struct@Methods+for+Converting]
2141 *
2142 * === Methods for Creating a Struct Subclass
2143 *
2144 * - ::new: Returns a new subclass of \Struct.
2145 *
2146 * === Methods for Querying
2147 *
2148 * - #hash: Returns the integer hash code.
2149 * - #size (aliased as #length): Returns the number of members.
2150 *
2151 * === Methods for Comparing
2152 *
2153 * - #==: Returns whether a given object is equal to +self+, using <tt>==</tt>
2154 * to compare member values.
2155 * - #eql?: Returns whether a given object is equal to +self+,
2156 * using <tt>eql?</tt> to compare member values.
2157 *
2158 * === Methods for Fetching
2159 *
2160 * - #[]: Returns the value associated with a given member name.
2161 * - #to_a (aliased as #values, #deconstruct): Returns the member values in +self+ as an array.
2162 * - #deconstruct_keys: Returns a hash of the name/value pairs
2163 * for given member names.
2164 * - #dig: Returns the object in nested objects that is specified
2165 * by a given member name and additional arguments.
2166 * - #members: Returns an array of the member names.
2167 * - #select (aliased as #filter): Returns an array of member values from +self+,
2168 * as selected by the given block.
2169 * - #values_at: Returns an array containing values for given member names.
2170 *
2171 * === Methods for Assigning
2172 *
2173 * - #[]=: Assigns a given value to a given member name.
2174 *
2175 * === Methods for Iterating
2176 *
2177 * - #each: Calls a given block with each member name.
2178 * - #each_pair: Calls a given block with each member name/value pair.
2179 *
2180 * === Methods for Converting
2181 *
2182 * - #inspect (aliased as #to_s): Returns a string representation of +self+.
2183 * - #to_h: Returns a hash of the member name/value pairs in +self+.
2184 *
2185 */
2186void
2187InitVM_Struct(void)
2188{
2189 rb_cStruct = rb_define_class("Struct", rb_cObject);
2191
2193 rb_define_singleton_method(rb_cStruct, "new", rb_struct_s_def, -1);
2194#if 0 /* for RDoc */
2195 rb_define_singleton_method(rb_cStruct, "keyword_init?", rb_struct_s_keyword_init_p, 0);
2196 rb_define_singleton_method(rb_cStruct, "members", rb_struct_s_members_m, 0);
2197#endif
2198
2199 rb_define_method(rb_cStruct, "initialize", rb_struct_initialize_m, -1);
2200 rb_define_method(rb_cStruct, "initialize_copy", rb_struct_init_copy, 1);
2201
2202 rb_define_method(rb_cStruct, "==", rb_struct_equal, 1);
2203 rb_define_method(rb_cStruct, "eql?", rb_struct_eql, 1);
2204 rb_define_method(rb_cStruct, "hash", rb_struct_hash, 0);
2205
2206 rb_define_method(rb_cStruct, "inspect", rb_struct_inspect, 0);
2207 rb_define_alias(rb_cStruct, "to_s", "inspect");
2208 rb_define_method(rb_cStruct, "to_a", rb_struct_to_a, 0);
2209 rb_define_method(rb_cStruct, "to_h", rb_struct_to_h, 0);
2210 rb_define_method(rb_cStruct, "values", rb_struct_to_a, 0);
2211 rb_define_method(rb_cStruct, "size", rb_struct_size, 0);
2212 rb_define_method(rb_cStruct, "length", rb_struct_size, 0);
2213
2214 rb_define_method(rb_cStruct, "each", rb_struct_each, 0);
2215 rb_define_method(rb_cStruct, "each_pair", rb_struct_each_pair, 0);
2216 rb_define_method(rb_cStruct, "[]", rb_struct_aref, 1);
2217 rb_define_method(rb_cStruct, "[]=", rb_struct_aset, 2);
2218 rb_define_method(rb_cStruct, "select", rb_struct_select, -1);
2219 rb_define_method(rb_cStruct, "filter", rb_struct_select, -1);
2220 rb_define_method(rb_cStruct, "values_at", rb_struct_values_at, -1);
2221
2222 rb_define_method(rb_cStruct, "members", rb_struct_members_m, 0);
2223 rb_define_method(rb_cStruct, "dig", rb_struct_dig, -1);
2224
2225 rb_define_method(rb_cStruct, "deconstruct", rb_struct_to_a, 0);
2226 rb_define_method(rb_cStruct, "deconstruct_keys", rb_struct_deconstruct_keys, 1);
2227
2228 rb_cData = rb_define_class("Data", rb_cObject);
2229
2230 rb_undef_method(CLASS_OF(rb_cData), "new");
2231 rb_undef_alloc_func(rb_cData);
2232 rb_define_singleton_method(rb_cData, "define", rb_data_s_def, -1);
2233
2234#if 0 /* for RDoc */
2235 rb_define_singleton_method(rb_cData, "members", rb_data_s_members_m, 0);
2236#endif
2237
2238 rb_define_method(rb_cData, "initialize", rb_data_initialize_m, -1);
2239 rb_define_method(rb_cData, "initialize_copy", rb_data_init_copy, 1);
2240
2241 rb_define_method(rb_cData, "==", rb_data_equal, 1);
2242 rb_define_method(rb_cData, "eql?", rb_data_eql, 1);
2243 rb_define_method(rb_cData, "hash", rb_data_hash, 0);
2244
2245 rb_define_method(rb_cData, "inspect", rb_data_inspect, 0);
2246 rb_define_alias(rb_cData, "to_s", "inspect");
2247 rb_define_method(rb_cData, "to_h", rb_data_to_h, 0);
2248
2249 rb_define_method(rb_cData, "members", rb_data_members_m, 0);
2250
2251 rb_define_method(rb_cData, "deconstruct", rb_data_deconstruct, 0);
2252 rb_define_method(rb_cData, "deconstruct_keys", rb_data_deconstruct_keys, 1);
2253
2254 rb_define_method(rb_cData, "with", rb_data_with, -1);
2255}
2256
2257#undef rb_intern
2258void
2259Init_Struct(void)
2260{
2261 id_members = rb_intern("__members__");
2262 id_back_members = rb_intern("__members_back__");
2263 id_keyword_init = rb_intern("__keyword_init__");
2264
2265 InitVM(Struct);
2266}
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define RB_OBJ_FREEZE
Just another name of rb_obj_freeze_inline.
Definition fl_type.h:92
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
Definition class.c:1701
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition class.c:1484
VALUE rb_class_new(VALUE super)
Creates a new, anonymous class.
Definition class.c:864
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2805
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition class.c:1520
VALUE rb_define_class_id_under(VALUE outer, ID id, VALUE super)
Identical to rb_define_class_under(), except it takes the name in ID instead of C's string.
Definition class.c:1559
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
Definition class.c:1475
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
Definition class.c:2853
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
Definition class.c:2673
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
Definition class.c:3143
int rb_keyword_given_p(void)
Determines if the current method is given a keyword argument.
Definition eval.c:1050
int rb_block_given_p(void)
Determines if the current method is given a block.
Definition eval.c:1037
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
Definition class.c:2932
#define rb_str_new2
Old name of rb_str_new_cstr.
Definition string.h:1674
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
Definition object.h:41
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
Definition fl_type.h:136
#define rb_str_cat2
Old name of rb_str_cat_cstr.
Definition string.h:1682
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define T_STRUCT
Old name of RUBY_T_STRUCT.
Definition value_type.h:79
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:134
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
Definition assume.h:29
#define SYM2ID
Old name of RB_SYM2ID.
Definition symbol.h:45
#define FIX2UINT
Old name of RB_FIX2UINT.
Definition int.h:42
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:206
#define rb_ary_new4
Old name of rb_ary_new_from_values.
Definition array.h:659
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
#define FIX2INT
Old name of RB_FIX2INT.
Definition int.h:41
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define ALLOC_N
Old name of RB_ALLOC_N.
Definition memory.h:399
#define LONG2NUM
Old name of RB_LONG2NUM.
Definition long.h:50
#define Qtrue
Old name of RUBY_Qtrue.
#define ST2FIX
Old name of RB_ST2FIX.
Definition st_data_t.h:33
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define NIL_P
Old name of RB_NIL_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
Definition fl_type.h:59
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define NUM2LONG
Old name of RB_NUM2LONG.
Definition long.h:51
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
Definition fl_type.h:129
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition eval.c:683
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1430
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
VALUE rb_eIndexError
IndexError exception.
Definition error.c:1432
VALUE rb_class_superclass(VALUE klass)
Queries the parent of the given class.
Definition object.c:2220
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
Definition object.c:2205
VALUE rb_class_new_instance_kw(int argc, const VALUE *argv, VALUE klass, int kw_splat)
Identical to rb_class_new_instance(), except you can specify how to handle the last element of the gi...
Definition object.c:2193
VALUE rb_mEnumerable
Enumerable module.
Definition enum.c:27
VALUE rb_cStruct
Struct class.
Definition struct.c:33
VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
Identical to rb_class_new_instance(), except it passes the passed keywords if any to the #initialize ...
Definition object.c:2182
int rb_eql(VALUE lhs, VALUE rhs)
Checks for equality of the passed objects, in terms of Object#eql?.
Definition object.c:190
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
Definition object.c:265
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
Definition object.c:687
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
Definition object.c:177
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
Definition object.c:910
#define RGENGC_WB_PROTECTED_STRUCT
This is a compile-time flag to enable/disable write barrier for struct RStruct.
Definition gc.h:468
Defines RBIMPL_HAS_BUILTIN.
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_get_values_at(VALUE obj, long olen, int argc, const VALUE *argv, VALUE(*func)(VALUE obj, long oidx))
This was a generalisation of Array#values_at, Struct#values_at, and MatchData#values_at.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
void rb_mem_clear(VALUE *buf, long len)
Fills the memory region with a series of RUBY_Qnil.
VALUE rb_ary_join(VALUE ary, VALUE sep)
Recursively stringises the elements of the passed array, flattens that result, then joins the sequenc...
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn)
This roughly resembles return enum_for(__callee__) unless block_given?.
Definition enumerator.h:206
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
Definition error.h:35
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
Definition error.h:284
int rb_is_const_id(ID id)
Classifies the given ID, then sees if it is a constant.
Definition symbol.c:1079
int rb_is_local_id(ID id)
Classifies the given ID, then sees if it is a local variable.
Definition symbol.c:1109
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
Definition string.h:941
#define rb_hash_end(h)
Just another name of st_hash_end.
Definition string.h:944
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
Definition string.c:3772
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
Definition random.c:1776
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1655
VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc,...)
Identical to rb_struct_define_without_accessor(), except it defines the class under the specified nam...
Definition struct.c:460
VALUE rb_struct_define_under(VALUE space, const char *name,...)
Identical to rb_struct_define(), except it defines the class under the specified namespace instead of...
Definition struct.c:506
VALUE rb_struct_new(VALUE klass,...)
Creates an instance of the given struct.
Definition struct.c:856
VALUE rb_struct_initialize(VALUE self, VALUE values)
Mass-assigns a struct's fields.
Definition struct.c:795
VALUE rb_struct_define_without_accessor(const char *name, VALUE super, rb_alloc_func_t func,...)
Identical to rb_struct_define(), except it does not define accessor methods.
Definition struct.c:473
VALUE rb_struct_define(const char *name,...)
Defines a struct class.
Definition struct.c:486
VALUE rb_struct_alloc(VALUE klass, VALUE values)
Identical to rb_struct_new(), except it takes the field values as a Ruby array.
Definition struct.c:850
VALUE rb_data_define(VALUE super,...)
Defines an anonymous data class.
Definition struct.c:1713
VALUE rb_struct_alloc_noinit(VALUE klass)
Allocates an instance of the given class.
Definition struct.c:406
VALUE rb_struct_s_members(VALUE klass)
Queries the list of the names of the fields of the given struct class.
Definition struct.c:68
VALUE rb_struct_members(VALUE self)
Queries the list of the names of the fields of the class of the given struct object.
Definition struct.c:82
VALUE rb_struct_getmember(VALUE self, ID key)
Identical to rb_struct_aref(), except it takes ID instead of VALUE.
Definition struct.c:233
VALUE rb_exec_recursive(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
"Recursion" API entry point.
VALUE rb_exec_recursive_paired(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE p, VALUE h)
Identical to rb_exec_recursive(), except it checks for the recursion on the ordered pair of { g,...
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1985
VALUE rb_mod_remove_const(VALUE space, VALUE name)
Resembles Module#remove_const.
Definition variable.c:3516
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
Definition variable.c:498
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
Definition variable.c:3740
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
Definition variable.c:379
VALUE(* rb_alloc_func_t)(VALUE klass)
This is the type of functions that ruby calls when trying to allocate an object.
Definition vm.h:216
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
Definition vm_method.c:1622
VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
Identical to rb_obj_instance_eval(), except it evaluates within the context of module.
Definition vm_eval.c:2396
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
VALUE rb_check_symbol(volatile VALUE *namep)
Identical to rb_check_id(), except it returns an instance of rb_cSymbol instead.
Definition symbol.c:1190
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
Definition string.c:12715
ID rb_to_id(VALUE str)
Definition string.c:12705
int off
Offset inside of ptr.
Definition io.h:5
int len
Length of the buffer.
Definition io.h:8
VALUE rb_yield_values(int n,...)
Identical to rb_yield(), except it takes variadic number of parameters and pass them to the block.
Definition vm_eval.c:1384
VALUE rb_yield(VALUE val)
Yields the block.
Definition vm_eval.c:1372
#define rb_long2int
Just another name of rb_long2int_inline.
Definition long.h:62
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
Definition rarray.h:281
static VALUE * RARRAY_PTR(VALUE ary)
Wild use of a C pointer.
Definition rarray.h:366
#define RARRAY_AREF(a, i)
Definition rarray.h:403
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define RHASH_SIZE(h)
Queries the size of the hash.
Definition rhash.h:69
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
Definition string.c:1754
VALUE rb_struct_aset(VALUE st, VALUE k, VALUE v)
Resembles Struct#[]=.
Definition struct.c:1269
VALUE rb_struct_size(VALUE st)
Returns the number of struct members.
Definition struct.c:1519
VALUE rb_struct_aref(VALUE st, VALUE k)
Resembles Struct#[].
Definition struct.c:1231
#define InitVM(ext)
This macro is for internal use.
Definition ruby.h:231
#define RB_PASS_KEYWORDS
Pass keywords, final argument should be a hash of keywords.
Definition scan_args.h:72
#define RTEST
This is an old name of RB_TEST.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376