Class: Java::ObjectOutputStream

Inherits:
Object
  • Object
show all
Includes:
ObjectStream
Defined in:
lib/javaobs.rb

Overview

A Ruby version of the Java ObjectOutputStream. The Ruby classes must have attached Java meta classes to attach UUID.

Constant Summary

Constants included from ObjectStream

Java::ObjectStream::PRIM_ARRAY, Java::ObjectStream::PRIM_BOOL, Java::ObjectStream::PRIM_BYTE, Java::ObjectStream::PRIM_CHAR, Java::ObjectStream::PRIM_DOUBLE, Java::ObjectStream::PRIM_FLOAT, Java::ObjectStream::PRIM_INT, Java::ObjectStream::PRIM_LONG, Java::ObjectStream::PRIM_OBJECT, Java::ObjectStream::PRIM_SHORT, Java::ObjectStream::SC_BLOCKDATA, Java::ObjectStream::SC_EXTERNALIZABLE, Java::ObjectStream::SC_SERIALIZABLE, Java::ObjectStream::SC_WRITE_METHOD, Java::ObjectStream::STREAM_MAGIC, Java::ObjectStream::STREAM_VERSION, Java::ObjectStream::TC_ARRAY, Java::ObjectStream::TC_BLOCKDATA, Java::ObjectStream::TC_BLOCKDATALONG, Java::ObjectStream::TC_CLASS, Java::ObjectStream::TC_CLASSDESC, Java::ObjectStream::TC_ENDBLOCKDATA, Java::ObjectStream::TC_EXCEPTION, Java::ObjectStream::TC_LONGSTRING, Java::ObjectStream::TC_NULL, Java::ObjectStream::TC_OBJECT, Java::ObjectStream::TC_PROXYCLASSDESC, Java::ObjectStream::TC_REFERENCE, Java::ObjectStream::TC_RESET, Java::ObjectStream::TC_STRING

Instance Method Summary collapse

Constructor Details

#initialize(str) ⇒ ObjectOutputStream

Create an o writer on with a stream.



579
580
581
582
583
584
585
586
 
# File 'lib/javaobs.rb', line 579

def initialize(str)
  @str = str
  @handles = {}
  @nextHandle = 0

  writeUShort(STREAM_MAGIC)
  writeShort(STREAM_VERSION)
end

Instance Method Details

#nextHandle ⇒ Object

Creates object reference handles.



434
435
436
437
438
 
# File 'lib/javaobs.rb', line 434

def nextHandle
  h = @nextHandle
  @nextHandle += 1
  h
end

#writeArray(klass, v) ⇒ Object

Write an array of objects.



441
442
443
444
445
446
447
 
# File 'lib/javaobs.rb', line 441

def writeArray(klass, v)
  type = klass.arrayType
  writeInt(v.length)
  v.each do |e|
    writeType(type, e)
  end
end

#writeBlockData(data) ⇒ Object

Writes a block of data to the stream.



450
451
452
453
454
455
456
457
458
459
460
461
 
# File 'lib/javaobs.rb', line 450

def writeBlockData(data)
  if (data.length <= 255)
    writeByte(TC_BLOCKDATA)
    writeByte(data.length)
  else
    writeByte(TC_BLOCKDATALONG)
    writeInt(data.length)
  end

  @str.write data
  writeByte(TC_ENDBLOCKDATA)
end

#writeBool(b) ⇒ Object 



429
 
# File 'lib/javaobs.rb', line 429

def writeBool(b); writeByte(b ? 1 : 0); end

#writeByte(b) ⇒ Object 



422
 
# File 'lib/javaobs.rb', line 422

def writeByte(b); @str.putc b; end

#writeClassDesc(klass) ⇒ Object

Writes the class description to the stream.



499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'lib/javaobs.rb', line 499

def writeClassDesc(klass)
  @handles[klass] = nextHandle

  writeString klass.javaName
  writeUID klass.uid
  writeByte klass.flags

  writeShort(klass.fields.length)
  klass.fields.each do |f|
    writeByte(f.type)
    writeString(f.name)
    writeObject(f.subtype) if f.subtype
  end

  writeByte(TC_ENDBLOCKDATA) # Annotations
  writeObject(klass.superClass)
end

#writeDouble(d) ⇒ Object 



426
 
# File 'lib/javaobs.rb', line 426

def writeDouble(d); @str.write [d].pack("G"); end

#writeFloat(f) ⇒ Object 



427
 
# File 'lib/javaobs.rb', line 427

def writeFloat(f); @str.write [f].pack("g"); end

#writeInt(i) ⇒ Object 



425
 
# File 'lib/javaobs.rb', line 425

def writeInt(i); @str.write [i].pack("i"); end

#writeLong(l) ⇒ Object 



431
 
# File 'lib/javaobs.rb', line 431

def writeLong(l); @str.write [l].pack("Q"); end

#writeObject(obj) ⇒ Object

Writes the object and class data to the stream. Will write a reference if the object has already been written once.



534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/javaobs.rb', line 534

def writeObject(obj)
 unless obj
   writeByte(TC_NULL)
 else
   handle = @handles[obj]
   if (handle)
     writeByte(TC_REFERENCE)
     writeShort(0x007E)
     writeShort(handle)
   else
     case obj
     when JavaClass
       writeByte(TC_CLASSDESC)
       writeClassDesc(obj)

     when JavaArray
       writeByte(TC_ARRAY)
       writeObject(obj.class.javaClass)
       writeArray(obj.class.javaClass, obj)
       @handles[obj] = nextHandle
   
     when String
       writeByte(TC_STRING)
       writeString(obj)
       @handles[obj] = nextHandle
   
     else
       writeByte(TC_OBJECT)
       klass = obj.class.javaClass
       writeObject(klass)
       @handles[obj] = nextHandle
       writeObjectData(klass, obj)
     end
   end
 end
end

#writeObjectData(klass, obj) ⇒ Object

Write the object and class to the stream.



518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/javaobs.rb', line 518

def writeObjectData(klass, obj)
  writeObjectData(klass.superClass, obj) if klass.superClass

  if klass.flags == SC_SERIALIZABLE
    klass.fields.each do |f|
      v = obj.send(f.name.intern)
      writeType(f.type, v)
    end
  else
    writeBlockData(obj.data)
  end
end

#writeObjects(objs) ⇒ Object

Write an array of objects to the stream.



572
573
574
575
576
 
# File 'lib/javaobs.rb', line 572

def writeObjects(objs)
  objs.each do |o|
    writeObject o
  end
end

#writeShort(s) ⇒ Object 



424
 
# File 'lib/javaobs.rb', line 424

def writeShort(s); @str.write [s].pack("s"); end

#writeString(s) ⇒ Object 



428
 
# File 'lib/javaobs.rb', line 428

def writeString(s); writeShort(s.length); @str.write s; end

#writeType(type, v) ⇒ Object

Reads a Java primitive type.



464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
 
# File 'lib/javaobs.rb', line 464

def writeType(type, v)
  case type
  when PRIM_BYTE
    writeByte(v)

  when PRIM_CHAR
    writeByte(v)

  when PRIM_DOUBLE
    writeDouble(v)

  when PRIM_FLOAT
    writeFloat(v)

  when PRIM_INT
    writeInt(v)

  when PRIM_LONG
    writeLong(v)

  when PRIM_SHORT
    writeShort(v)

  when PRIM_BOOL
    writeBool(v)

  when PRIM_OBJECT, PRIM_ARRAY
    writeObject(v)

  else
    raise SerializationError, "Unknown type #{type}"
  end
end

#writeUID(u) ⇒ Object 



430
 
# File 'lib/javaobs.rb', line 430

def writeUID(u); @str.write u; end

#writeUShort(s) ⇒ Object 



423
 
# File 'lib/javaobs.rb', line 423

def writeUShort(s); @str.write [s].pack("n"); end