Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
BEGIN LICENSE BLOCK ***** Version: CPL 1.0/GPL 2.0/LGPL 2.1 The contents of this file are subject to the Common Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.eclipse.org/legal/cpl-v10.html Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> Copyright (C) 2005 Charles O Nutter <headius@headius.com> Alternatively, the contents of this file may be used under the terms of either of the GNU General Public License Version 2 or later (the "GPL"), or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which case the provisions of the GPL or the LGPL are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of either the GPL or the LGPL, and not to allow others to use your version of this file under the terms of the CPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the GPL or the LGPL. If you do not delete the provisions above, a recipient may use your version of this file under the terms of any one of the CPL, the GPL or the LGPL. END LICENSE BLOCK ***
32
 
33
 package org.jruby;
34
 
35
 import static org.jruby.RubyEnumerator.enumeratorize;
36
 
37
 
56
 
57
 import static org.jruby.runtime.Visibility.*;
58
 
59
 import static org.jruby.javasupport.util.RuntimeHelpers.invokedynamic;
60
 import static org.jruby.runtime.invokedynamic.MethodNames.HASH;

Author(s):
jpetersen
64
 
65
 @JRubyClass(name="Struct")
66
 public class RubyStruct extends RubyObject {
67
     private final IRubyObject[] values;

    
Constructor for RubyStruct.

Parameters:
runtime
rubyClass
73
 
74
     private RubyStruct(Ruby runtime, RubyClass rubyClass) {
75
         super(runtime, rubyClass);
76
         
77
         int size = RubyNumeric.fix2int(getInternalVariable((RubyClass)rubyClass, "__size__"));
78
 
79
          = new IRubyObject[size];
80
 
81
         RuntimeHelpers.fillNil(, runtime);
82
     }
83
 
84
     public static RubyClass createStructClass(Ruby runtime) {
85
         RubyClass structClass = runtime.defineClass("Struct", runtime.getObject(), .);
86
         runtime.setStructClass(structClass);
87
         structClass.index = .;
88
         structClass.includeModule(runtime.getEnumerable());
89
         structClass.defineAnnotatedMethods(RubyStruct.class);
90
 
91
         return structClass;
92
     }
93
     
94
     @Override
95
     public int getNativeTypeIndex() {
96
         return .;
97
     }
98
     
99
     private static IRubyObject getInternalVariable(RubyClass type, String internedName) {
100
        RubyClass structClass = type.getRuntime().getStructClass();
101
        IRubyObject variable;
103
        while (type != null && type != structClass) {
104
            if ((variable = (IRubyObject)type.getInternalVariable(internedName)) != null) {
105
                return variable;
106
            }
108
            type = type.getSuperClass();
109
        }
111
        return type.getRuntime().getNil();
112
    }
114
    private RubyClass classOf() {
115
        return getMetaClass() instanceof MetaClass ? getMetaClass().getSuperClass() : getMetaClass();
116
    }
118
    private void modify() {
119
        testFrozen();
120
    }
121
    
123
    public RubyFixnum hash(ThreadContext context) {
124
        Ruby runtime = getRuntime();
125
        int h = getMetaClass().getRealClass().hashCode();
127
        for (int i = 0; i < .; i++) {
128
            h = (h << 1) | (h < 0 ? 1 : 0);
129
            h ^= RubyNumeric.num2long(invokedynamic(context, [i], ));
130
        }
131
        
132
        return runtime.newFixnum(h);
133
    }
135
    private IRubyObject setByName(String name, IRubyObject value) {
136
        RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__");
138
        assert !member.isNil() : "uninitialized struct";
140
        modify();
142
        for (int i = 0,k=member.getLength(); i < k; i++) {
143
            if (member.eltInternal(i).asJavaString().equals(name)) {
144
                return [i] = value;
145
            }
146
        }
148
        throw notStructMemberError(name);
149
    }
151
    private IRubyObject getByName(String name) {
152
        RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__");
154
        assert !member.isNil() : "uninitialized struct";
156
        for (int i = 0,k=member.getLength(); i < k; i++) {
157
            if (member.eltInternal(i).asJavaString().equals(name)) {
158
                return [i];
159
            }
160
        }
162
        throw notStructMemberError(name);
163
    }
165
    // Struct methods
166

    
Create new Struct class. MRI: rb_struct_s_def / make_struct 
172
    @JRubyMethod(name = "new", required = 1, rest = true, meta = true)
173
    public static RubyClass newInstance(IRubyObject recv, IRubyObject[] args, Block block) {
174
        String name = null;
175
        boolean nilName = false;
176
        Ruby runtime = recv.getRuntime();
178
        if (args.length > 0) {
179
            IRubyObject firstArgAsString = args[0].checkStringType();
180
            if (!firstArgAsString.isNil()) {
181
                name = ((RubyString)firstArgAsString).getByteList().toString();
182
            } else if (args[0].isNil()) {
183
                nilName = true;
184
            }
185
        }
187
        RubyArray member = runtime.newArray();
189
        for (int i = (name == null && !nilName) ? 0 : 1; i < args.length; i++) {
190
            member.append(runtime.newSymbol(args[i].asJavaString()));
191
        }
193
        RubyClass newStruct;
194
        RubyClass superClass = (RubyClass)recv;
196
        if (name == null || nilName) {
197
            newStruct = RubyClass.newClass(runtime, superClass);
198
            newStruct.setAllocator();
199
            newStruct.makeMetaClass(superClass.getMetaClass());
200
            newStruct.inherit(superClass);
201
        } else {
202
            if (!IdUtil.isConstant(name)) {
203
                throw runtime.newNameError("identifier " + name + " needs to be constant", name);
204
            }
206
            IRubyObject type = superClass.getConstantAt(name);
207
            if (type != null) {
208
                ThreadContext context = runtime.getCurrentContext();
209
                runtime.getWarnings().warn(., context.getFile(), context.getLine(), "redefining constant Struct::" + name);
210
                superClass.remove_const(context, runtime.newString(name));
211
            }
212
            newStruct = superClass.defineClassUnder(name, superClass, );
213
        }
215
        // set reified class to RubyStruct, for Java subclasses to use
216
        newStruct.setReifiedClass(RubyStruct.class);
217
        newStruct.index = .;
218
        
219
        newStruct.setInternalVariable("__size__", member.length());
220
        newStruct.setInternalVariable("__member__", member);
222
        newStruct.getSingletonClass().defineAnnotatedMethods(StructMethods.class);
224
        // define access methods.
225
        for (int i = (name == null && !nilName) ? 0 : 1; i < args.length; i++) {
226
            final String memberName = args[i].asJavaString();
227
            // if we are storing a name as well, index is one too high for values
228
            final int index = (name == null && !nilName) ? i : i - 1;
229
            newStruct.addMethod(memberName, new DynamicMethod(newStruct, ., .) {
230
                @Override
231
                public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) {
232
                    Arity.checkArgumentCount(context.runtime, name, args, 0, 0);
233
                    return ((RubyStruct)self).get(index);
234
                }
236
                @Override
237
                public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name) {
238
                    return ((RubyStruct)self).get(index);
239
                }
241
                @Override
242
                public DynamicMethod dup() {
243
                    return this;
244
                }
245
            });
246
            newStruct.addMethod(memberName + "=", new DynamicMethod(newStruct, ., .) {
247
                @Override
248
                public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) {
249
                    Arity.checkArgumentCount(context.runtime, name, args, 1, 1);
250
                    return ((RubyStruct)self).set(args[0], index);
251
                }
253
                @Override
254
                public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg) {
255
                    return ((RubyStruct)self).set(arg, index);
256
                }
258
                @Override
259
                public DynamicMethod dup() {
260
                    return this;
261
                }
262
            });
263
        }
264
        
265
        if (block.isGiven()) {
266
            // Struct bodies should be public by default, so set block visibility to public. JRUBY-1185.
267
            block.getBinding().setVisibility(.);
268
            block.yieldNonArray(runtime.getCurrentContext(), null, newStruct, newStruct);
269
        }
271
        return newStruct;
272
    }
273
    
274
    // For binding purposes on the newly created struct types
275
    public static class StructMethods {
276
        @JRubyMethod(name = {"new", "[]"}, rest = true)
277
        public static IRubyObject newStruct(IRubyObject recv, IRubyObject[] args, Block block) {
278
            return RubyStruct.newStruct(recv, args, block);
279
        }
281
        @JRubyMethod(name = {"new", "[]"})
282
        public static IRubyObject newStruct(IRubyObject recv, Block block) {
283
            return RubyStruct.newStruct(recv, block);
284
        }
286
        @JRubyMethod(name = {"new", "[]"})
287
        public static IRubyObject newStruct(IRubyObject recv, IRubyObject arg0, Block block) {
288
            return RubyStruct.newStruct(recv, arg0, block);
289
        }
291
        @JRubyMethod(name = {"new", "[]"})
292
        public static IRubyObject newStruct(IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) {
293
            return RubyStruct.newStruct(recv, arg0, arg1, block);
294
        }
296
        @JRubyMethod(name = {"new", "[]"})
297
        public static IRubyObject newStruct(IRubyObject recv, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
298
            return RubyStruct.newStruct(recv, arg0, arg1, arg2, block);
299
        }
301
        @JRubyMethod(name = "members", compat = .)
302
        public static IRubyObject members(IRubyObject recv, Block block) {
303
            return RubyStruct.members(recv, block);
304
        }
306
        @JRubyMethod(name = "members", compat = .)
307
        public static IRubyObject members19(IRubyObject recv, Block block) {
308
            return RubyStruct.members19(recv, block);
309
        }
310
    }

    
Create new Structure. MRI: struct_alloc 
317
    public static RubyStruct newStruct(IRubyObject recv, IRubyObject[] args, Block block) {
318
        RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv);
320
        struct.callInit(args, block);
322
        return struct;
323
    }
325
    public static RubyStruct newStruct(IRubyObject recv, Block block) {
326
        RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv);
328
        struct.callInit(block);
330
        return struct;
331
    }
333
    public static RubyStruct newStruct(IRubyObject recv, IRubyObject arg0, Block block) {
334
        RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv);
336
        struct.callInit(arg0, block);
338
        return struct;
339
    }
341
    public static RubyStruct newStruct(IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) {
342
        RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv);
344
        struct.callInit(arg0, arg1, block);
346
        return struct;
347
    }
349
    public static RubyStruct newStruct(IRubyObject recv, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
350
        RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv);
352
        struct.callInit(arg0, arg1, arg2, block);
354
        return struct;
355
    }
357
    private void checkSize(int length) {
358
        if (length > .) {
359
            throw getRuntime().newArgumentError("struct size differs (" + length +" for " + . + ")");
360
        }
361
    }
363
    @JRubyMethod(rest = true, visibility = )
364
    public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
365
        modify();
366
        checkSize(args.length);
368
        System.arraycopy(args, 0, , 0, args.length);
369
        RuntimeHelpers.fillNil(, args.length, ., context.runtime);
371
        return context.nil;
372
    }
374
    @JRubyMethod(visibility = )
375
    public IRubyObject initialize(ThreadContext context) {
376
        IRubyObject nil = context.nil;
377
        return initializeInternal(context, 0, nil, nil, nil);
378
    }
380
    @JRubyMethod(visibility = )
381
    public IRubyObject initialize(ThreadContext context, IRubyObject arg0) {
382
        IRubyObject nil = context.nil;
383
        return initializeInternal(context, 1, arg0, nil, nil);
384
    }
386
    @JRubyMethod(visibility = )
387
    public IRubyObject initialize(ThreadContext context, IRubyObject arg0, IRubyObject arg1) {
388
        return initializeInternal(context, 2, arg0, arg1, context.nil);
389
    }
391
    @JRubyMethod(visibility = )
392
    public IRubyObject initialize(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
393
        return initializeInternal(context, 3, arg0, arg1, arg2);
394
    }
395
    
396
    public IRubyObject initializeInternal(ThreadContext context, int provided, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) {
397
        modify();
398
        checkSize(provided);
400
        switch (provided) {
401
        case 3:
402
            [2] = arg2;
403
        case 2:
404
            [1] = arg1;
405
        case 1:
406
            [0] = arg0;
407
        }
408
        if (provided < .) {
409
            RuntimeHelpers.fillNil(, provided, ., context.runtime);
410
        }
412
        return getRuntime().getNil();
413
    }
414
    
415
    public static RubyArray members(IRubyObject recv, Block block) {
416
        RubyArray member = (RubyArray) getInternalVariable((RubyClass) recv, "__member__");
418
        assert !member.isNil() : "uninitialized struct";
420
        RubyArray result = recv.getRuntime().newArray(member.getLength());
421
        for (int i = 0,k=member.getLength(); i < k; i++) {
422
            // this looks weird, but it's because they're RubySymbol and that's java.lang.String internally
423
            result.append(recv.getRuntime().newString(member.eltInternal(i).asJavaString()));
424
        }
426
        return result;
427
    }
429
    public static RubyArray members19(IRubyObject recv, Block block) {
430
        RubyArray member = (RubyArray) getInternalVariable((RubyClass) recv, "__member__");
432
        assert !member.isNil() : "uninitialized struct";
434
        RubyArray result = recv.getRuntime().newArray(member.getLength());
435
        for (int i = 0,k=member.getLength(); i < k; i++) {
436
            result.append(member.eltInternal(i));
437
        }
439
        return result;
440
    }
442
    @JRubyMethod(name = "members", compat = .)
443
    public RubyArray members() {
444
        return members(classOf(), .);
445
    }
447
    @JRubyMethod(name = "members", compat = .)
448
    public RubyArray members19() {
449
        return members19(classOf(), .);
450
    }
451
    
453
    public RubyArray select(ThreadContext context, Block block) {
454
        RubyArray array = RubyArray.newArray(context.runtime);
455
        
456
        for (int i = 0; i < .; i++) {
457
            if (block.yield(context, [i]).isTrue()) {
458
                array.append([i]);
459
            }
460
        }
461
        
462
        return array;
463
    }
465
    public IRubyObject set(IRubyObject value, int index) {
466
        modify();
468
        return [index] = value;
469
    }
471
    private RaiseException notStructMemberError(String name) {
472
        return getRuntime().newNameError("no member '" + name + "' in struct", name);
473
    }
475
    public IRubyObject get(int index) {
476
        return [index];
477
    }
479
    @Override
480
    public void copySpecialInstanceVariables(IRubyObject clone) {
481
        RubyStruct struct = (RubyStruct)clone;
482
        System.arraycopy(, 0, struct.values, 0, .);
483
    }
485
    @JRubyMethod(name = "==", required = 1)
486
    public IRubyObject op_equal(final ThreadContext context, IRubyObject other) {
487
        if (this == other) return getRuntime().getTrue();
488
        if (!(other instanceof RubyStruct)) return getRuntime().getFalse();
489
        if (getMetaClass().getRealClass() != other.getMetaClass().getRealClass()) return getRuntime().getFalse();
490
        
491
        final Ruby runtime = getRuntime();
492
        final RubyStruct otherStruct = (RubyStruct)other;
494
        // identical
495
        if (other == this) return runtime.getTrue();
497
        // recursion guard
498
        return runtime.execRecursiveOuter(new Ruby.RecursiveFunction() {
499
            public IRubyObject call(IRubyObject obj, boolean recur) {
500
                if (recur) {
501
                    return runtime.getTrue();
502
                }
503
                for (int i = 0; i < .; i++) {
504
                    if (!equalInternal(context, [i], otherStruct.values[i])) return runtime.getFalse();
505
                }
506
                return runtime.getTrue();
507
            }
508
        }, this);
509
    }
510
    
511
    @JRubyMethod(name = "eql?", required = 1)
512
    public IRubyObject eql_p(final ThreadContext context, IRubyObject other) {
513
        if (this == other) return getRuntime().getTrue();
514
        if (!(other instanceof RubyStruct)) return getRuntime().getFalse();
515
        if (getMetaClass() != other.getMetaClass()) return getRuntime().getFalse();
516
        
517
        final Ruby runtime = getRuntime();
518
        final RubyStruct otherStruct = (RubyStruct)other;
520
        // identical
521
        if (other == this) return runtime.getTrue();
523
        // recursion guard
524
        return runtime.execRecursiveOuter(new Ruby.RecursiveFunction() {
525
            public IRubyObject call(IRubyObject obj, boolean recur) {
526
                if (recur) {
527
                    return runtime.getTrue();
528
                }
529
                for (int i = 0; i < .; i++) {
530
                    if (!eqlInternal(context, [i], otherStruct.values[i])) return runtime.getFalse();
531
                }
532
                return runtime.getTrue();
533
            }
534
        }, this);
535
    }

    
inspect_struct 
540
    private IRubyObject inspectStruct(final ThreadContext context) {    
541
        RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__");
543
        assert !member.isNil() : "uninitialized struct";
545
        ByteList buffer = new ByteList("#<struct ".getBytes());
546
        buffer.append(getMetaClass().getRealClass().getRealClass().getName().getBytes());
547
        buffer.append(' ');
549
        for (int i = 0,k=member.getLength(); i < k; i++) {
550
            if (i > 0) buffer.append(',').append(' ');
551
            // FIXME: MRI has special case for constants here 
552
            buffer.append(RubyString.objAsString(context, member.eltInternal(i)).getByteList());
553
            buffer.append('=');
554
            buffer.append(inspect(context, [i]).getByteList());
555
        }
557
        buffer.append('>');
558
        return getRuntime().newString(buffer); // OBJ_INFECT        
559
    }
561
    @JRubyMethod(name = {"inspect", "to_s"})
562
    public IRubyObject inspect(ThreadContext context) {
563
        if (getRuntime().isInspecting(this)) return getRuntime().newString("#<struct " + getMetaClass().getRealClass().getName() + ":...>");
565
        try {
566
            getRuntime().registerInspecting(this);
567
            return inspectStruct(context);
568
        } finally {
569
            getRuntime().unregisterInspecting(this);
570
        }
571
    }
573
    @JRubyMethod(name = {"to_a", "values"})
574
    public RubyArray to_a() {
575
        return getRuntime().newArray();
576
    }
578
    @JRubyMethod(name = {"size", "length"} )
579
    public RubyFixnum size() {
580
        return getRuntime().newFixnum(.);
581
    }
583
    public IRubyObject eachInternal(ThreadContext context, Block block) {
584
        for (int i = 0; i < .; i++) {
585
            block.yield(context, [i]);
586
        }
588
        return this;
589
    }
592
    public IRubyObject each(final ThreadContext context, final Block block) {
593
        return block.isGiven() ? eachInternal(context, block) : enumeratorize(context.runtime, this, "each");
594
    }
596
    public IRubyObject each_pairInternal(ThreadContext context, Block block) {
597
        RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__");
599
        assert !member.isNil() : "uninitialized struct";
601
        for (int i = 0; i < .; i++) {
602
            block.yield(context, getRuntime().newArrayNoCopy(new IRubyObject[]{member.eltInternal(i), [i]}));
603
        }
605
        return this;
606
    }
609
    public IRubyObject each_pair(final ThreadContext context, final Block block) {
610
        return block.isGiven() ? each_pairInternal(context, block) : enumeratorize(context.runtime, this, "each_pair");
611
    }
613
    @JRubyMethod(name = "[]", required = 1)
614
    public IRubyObject aref(IRubyObject key) {
615
        if (key instanceof RubyString || key instanceof RubySymbol) {
616
            return getByName(key.asJavaString());
617
        }
619
        int idx = RubyNumeric.fix2int(key);
621
        idx = idx < 0 ? . + idx : idx;
623
        if (idx < 0) {
624
            throw getRuntime().newIndexError("offset " + idx + " too small for struct(size:" + . + ")");
625
        } else if (idx >= .) {
626
            throw getRuntime().newIndexError("offset " + idx + " too large for struct(size:" + . + ")");
627
        }
629
        return [idx];
630
    }
632
    @JRubyMethod(name = "[]=", required = 2)
633
    public IRubyObject aset(IRubyObject key, IRubyObject value) {
634
        if (key instanceof RubyString || key instanceof RubySymbol) {
635
            return setByName(key.asJavaString(), value);
636
        }
638
        int idx = RubyNumeric.fix2int(key);
640
        idx = idx < 0 ? . + idx : idx;
642
        if (idx < 0) {
643
            throw getRuntime().newIndexError("offset " + idx + " too small for struct(size:" + . + ")");
644
        } else if (idx >= .) {
645
            throw getRuntime().newIndexError("offset " + idx + " too large for struct(size:" + . + ")");
646
        }
648
        modify();
649
        return [idx] = value;
650
    }
651
    
652
    // FIXME: This is copied code from RubyArray.  Both RE, Struct, and Array should share one impl
653
    // This is also hacky since I construct ruby objects to access ruby arrays through aref instead
654
    // of something lower.
655
    @JRubyMethod(rest = true)
656
    public IRubyObject values_at(IRubyObject[] args) {
657
        int olen = .;
658
        RubyArray result = getRuntime().newArray(args.length);
660
        for (int i = 0; i < args.length; i++) {
661
            if (args[i] instanceof RubyFixnum) {
662
                result.append(aref(args[i]));
663
                continue;
664
            }
666
            int beglen[];
667
            if (!(args[i] instanceof RubyRange)) {
668
            } else if ((beglen = ((RubyRange) args[i]).begLenInt(olen, 0)) == null) {
669
                continue;
670
            } else {
671
                int beg = beglen[0];
672
                int len = beglen[1];
673
                int end = len;
674
                for (int j = 0; j < end; j++) {
675
                    result.append(aref(getRuntime().newFixnum(j + beg)));
676
                }
677
                continue;
678
            }
679
            result.append(aref(getRuntime().newFixnum(RubyNumeric.num2long(args[i]))));
680
        }
682
        return result;
683
    }
685
    public static void marshalTo(RubyStruct struct, MarshalStream output) throws java.io.IOException {
686
        output.registerLinkTarget(struct);
687
        output.dumpDefaultObjectHeader('S', struct.getMetaClass());
689
        RubyArray array = (RubyArray)getInternalVariable(struct.classOf(), "__member__");
690
        output.writeInt(array.size());
692
        for (int i = 0; i < array.size(); i++) {
693
            RubySymbol name = (RubySymbol) array.eltInternal(i);
694
            output.dumpObject(name);
695
            output.dumpObject(struct.values[i]);
696
        }
697
    }
699
    public static RubyStruct unmarshalFrom(UnmarshalStream input) throws java.io.IOException {
700
        Ruby runtime = input.getRuntime();
702
        RubySymbol className = (RubySymbol) input.unmarshalObject(false);
703
        RubyClass rbClass = pathToClass(runtime, className.asJavaString());
704
        if (rbClass == null) {
705
            throw runtime.newNameError("uninitialized constant " + className, className.asJavaString());
706
        }
708
        RubyArray mem = members(rbClass, .);
710
        int len = input.unmarshalInt();
711
        IRubyObject[] values;
712
        if (len == 0) {
713
            values = .;
714
        } else {
715
            values = new IRubyObject[len];
716
            RuntimeHelpers.fillNil(values, runtime);
717
        }
719
        // FIXME: This could all be more efficient, but it's how struct works
720
        RubyStruct result;
721
        if (runtime.is1_9()) {
722
            // 1.9 does not appear to call initialize (JRUBY-5875)
723
            result = new RubyStruct(runtime, rbClass);
724
        } else {
725
            result = newStruct(rbClass, values, .);
726
        }
727
        input.registerLinkTarget(result);
728
        
729
        for(int i = 0; i < len; i++) {
730
            IRubyObject slot = input.unmarshalObject(false);
731
            if(!mem.eltInternal(i).toString().equals(slot.toString())) {
732
                throw runtime.newTypeError("struct " + rbClass.getName() + " not compatible (:" + slot + " for :" + mem.eltInternal(i) + ")");
733
            }
734
            result.aset(runtime.newFixnum(i), input.unmarshalObject());
735
        }
736
        return result;
737
    }
739
    private static RubyClass pathToClass(Ruby runtime, String path) {
740
        // FIXME: Throw the right ArgumentError's if the class is missing
741
        // or if it's a module.
742
        return (RubyClass) runtime.getClassFromPath(path);
743
    }
744
    
745
    private static ObjectAllocator STRUCT_INSTANCE_ALLOCATOR = new ObjectAllocator() {
746
        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
747
            RubyStruct instance = new RubyStruct(runtime, klass);
748
            
749
            instance.setMetaClass(klass);
750
            
751
            return instance;
752
        }
753
    };
754
    
755
    @Override
756
    @JRubyMethod(required = 1)
757
    public IRubyObject initialize_copy(IRubyObject arg) {
758
        if (this == arg) return this;
759
        RubyStruct original = (RubyStruct) arg;
760
        
761
        System.arraycopy(original.values, 0, , 0, original.values.length);
763
        return this;
764
    }
765