Object serialization: Difference between revisions

=={{header|Ada}}==

This file contains the package specification containing the public definitions of the inheritance tree rooted at the type ''Message''. Each type in the inheritance tree has its own print procedure.

 

package Messages is

procedure Print(Item : Control_Message);

 

The next portion contains the implementation of the procedures defined in the package specification.

with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;

with Ada.Float_Text_IO; use Ada.Float_Text_IO;

end Display;

 

The final section of code creates objects of the three message types and performs the printing, writing, and reading. The Ada attributes '' 'Class'Output'' serialize the object and write it to the specified stream. The '' 'Class'Input'' attributes call a function automatically provided by the compiler which reads from the specified stream file and returns the object read. The ''Display'' procedure takes an object in the inheritance tree rooted at ''Message'' and dispatches the correct print procedure.

 

with Ada.Streams.Stream_Io; use Ada.Streams.Stream_Io;

with Ada.Calendar; use Ada.Calendar;

end loop;

Close(The_File);

Output results:

Time Stamp:2007-3-9

Serialization in ''ALGOL 68'' is achieved through a technique called

''straightening''.

FORMAT entity repr = $"Name: "g", Created:"g$;

MODE PERSON = STRUCT(ENTITY entity, STRING email);

printf((person repr, i1, $l$));

'''flex'''ible length arrays (including '''string'''s), and tagged-'''union'''

types are problematic as the lengths of the arrays, and the ''tag'' of the

Name: Entity, Created: +20111111

</pre>

 

=={{header|C++}}==

compiled with g++ -lboost_serialization serializationtest3.cpp -o serializationtest3

 

#include <fstream>

#include <boost/serialization/string.hpp>

w2.print( ) ;

return 0 ;

creating the following output:

<pre>

wage per hour: 55.35

</pre>

 

=={{header|Caché ObjectScript}}==

 

{

 

Property Department As %String [ Private ];

 

 

{

 

Property HourlyPay As %Numeric [ Private ];

 

 

{

 

Property Workers As list Of Worker;

 

 

{{out|Examples}}

{{libheader|cl-serializer}}

 

`(with-open-file (,stream ,pathname

:element-type '(unsigned-byte 8)

 

(defclass person (entity)

 

And now the REPL log:

 

(make-instance 'person))

 

Slots with :INSTANCE allocation:

NAME = "The Nameless One"

 

=={{header|D}}==

Run "pbcompiler test.proto" to generate the serializable code. It should generate a D code file named test.d.

In your main file, use the following code:

import std.stdio;

import std.file;

writefln("Output data:");

base.print;

 

=={{header|E}}==

(Inheritance, while supported by various features and patterns, is not a preferred design component in [[E]]; nor are simple record data structures.)

 

return def event {

to __printOn(out) { out.print(`@@$time`) }

to getPosition() { return position }

}

 

After defining our data types, we can prepare to serialize them.

 

surgeon.addExit(makeEvent, "makeEvent")

 

The 'exits' of the surgeon (so called because it cuts and joins object subgraphs) specify the points at which serialization should stop, instead replacing references to the objects with the specified names. On unserialization, the names are looked up and replaced with the corresponding objects. (The surgeon provides default exits for such things as <tt>false</tt>, <tt>true</tt>, <tt>null</tt>, and the list constructor.)

makeArrival(timer.now(), "Smith", 7)]

 

stdout.println(objs)

<file:objects.dat>.setBytes(surgeon.serialize(objs))

=={{header|Erlang}}==

Erlang is not object oriented. This code is based upon my understanding of the Algol 68 example above.

-module( object_serialization ).

 

print( Entity ),

io:fwrite( "\temail: ~p~n", [Email] ).

{{out}}

<pre>

Entity: name: "Entity", date: 20111111

</pre>

 

=={{header|Go}}==

 

A note on object oriented stuff, the object hierarchy required by the task description is implemented here with embedded structs. The polymorphism required by the task description is handled nicely with an interface. The functional polymorphism is orthogonal to the object hierarchy, not conflated with it.

 

import (

fmt.Println(" collie, not trained, doesn't catch frisbee")

}

Output:

<pre>created:

=={{header|Groovy}}==

Sample Serializable Classes (borrowed from Java example. Sorta.):

static final serialVersionUID = 3504465751164822571L

String name = 'Thingamabob'

Person() { name = 'Clement' }

Person(name) { this.name = name }

 

Writing objects:

if (objectStore.exists()) { objectStore.delete() }

assert ! objectStore.exists()

os << new Person('Schroeder')

} catch (e) { throw new Exception(e) } finally { os?.close() }

 

Reading objects:

try {

is = objectStore.newObjectInputStream(this.class.classLoader)

 

objectStore.delete()

 

Output:

[lists, are, serializable]

Schroeder</pre>

 

=={{header|J}}==

This should be sufficient for this task:

 

serializeObject=:3 :0

p=. copath y

print__r1''

print__k1''

 

Here is how the last part looks in action:

 

room size small

print__K''

kitchen size medium

print__s1''

 

Note also that J does not attempt to distinguish, at the language level, between an object reference and something that looks like an object reference but is not. This must be done at the application level, which in turn can create a variety of opportunities and/or burdens for the program designer.

 

=={{header|Java}}==

 

// classes must implement java.io.Serializable in order to be serializable

}

}

 

=={{header|Objective-C}}==

There exists also a way of serializing without the GNUstep/Cocoa framework, using the runtime of Objective-C (so it could be slightly implementation dependent, see [[wp:Serialization#Objective-C|Serialization on Wikipedia]]). (I will work on it and will put here a full working example compatible with the task).

 

 

// a fantasy two level hierarchy

int numberOfLegs;

}

- (void) dump;

@end

 

@implementation Animal

{

if ((self = [super init])) {

numberOfLegs = legs;

}

return self;

}

- (void) dump

[coder encodeInt: numberOfLegs forKey: @"Animal.legs"];

}

{

if ((self = [super init])) {

numberOfLegs = [coder decodeIntForKey: @"Animal.legs"];

}

NSMutableArray *eatenList;

}

- (void) addEatenThing: (NSString*)thing;

@end

 

@implementation Mammal

{

if ((self = [super init])) {

return self;

}

{

if ((self = [super initWithName: name andLegs: 4])) {

{

[eatenList addObject: thing];

}

- (void) dump

[super dump];

NSLog(@"has fur? %@", (hasFur) ? @"yes" : @"no" );

NSLog(@"it has eaten %d things:", [eatenList count]);

NSLog(@"it has eaten a %@", element);

NSLog(@"end of eaten things list");

[coder encodeObject: eatenList forKey: @"Mammal.eaten"];

}

{

if ((self = [super initWithCoder: coder])) {

hasFur = [coder decodeBoolForKey: @"Mammal.hasFur"];

}

return self;

int main()

{

 

 

 

 

 

 

 

return EXIT_SUCCESS;

 

=={{header|OCaml}}==

Objects which contain methods are difficult to serialize because it will want to serialize those methods too, but functions usually cannot be serialized. Instead, here we perform the task on non-object datatypes, with an outside function to print them.

 

 

let create_entity () = { name = "Entity" }

 

print_entity result1;;

 

=={{header|Oz}}==

 

 

For a general solution, see [[Object Serialization/Oz]].

=={{header|Perl}}==

{{libheader|Storable}}

package Greeting;

sub new {

print $g2->stringify;

print $s2->stringify;

 

{{libheader|MooseX}}

 

The same, using [[MooseX]] to serialize to [[uses format::JSON]].

 

class Greeting {

print $g2->string;

print $s2->string;

This time the objects were serialized to the [http://www.json.org/ JSON] format. Other supported formats are [http://search.cpan.org/perldoc?Storable Storable] and [http://www.yaml.org/ YAML].

 

=={{header|PHP}}==

Serialization in PHP is straightforward. The built-in function [http://www.php.net/manual/en/function.serialize.php serialize()] handles it in a single statement.

In order to un-serialize the object, use the [http://www.php.net/manual/en/function.unserialize.php unserialize()] function. Note that the class of object must be defined in the script where un-serialization takes place, or the class' methods will be lost.

 

back. This functionality is also used internally for database access and

interprocess-communication.

# x y

 

(out "objects.dat"

(pr (val P) (getl P))

(putl (setq A (box (rd))) (rd))

(putl (setq B (box (rd))) (rd)) )

 

(print> A)

Output:

<pre>Point 3,4

 

=={{header|Python}}==

# serialization in python is accomplished via the Pickle module.

# Alternatively, one can use the cPickle module if speed is the key,

 

i1.printName()

 

=={{header|Ruby}}==

The core class <code>[http://www.ruby-doc.org/core/classes/Marshal.html Marshal]</code> handles object serialization. The <code>dump</code> method serializes an object, and the <code>load</code> method reconstitutes it.

def initialize(specialty=nil)

@specialty=specialty

end.join("\n\n")

)

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

''This example uses an experimental package, available from [http://wiki.tcl.tk/23444 The Tcler's Wiki].

package require TclOO::serializer 0.1

 

set obj [oo::deserialize [read $f]]

close $f

 

{{omit from|AWK}}

{{omit from|Fortran}}

{{omit from|M4}}

{{omit from|Maxima}}

{{omit from|Metafont}}

{{omit from|Octave}}

{{omit from|PARI/GP}}

{{omit from|Retro}}

{{omit from|REXX}}

{{omit from|TI-83 BASIC}}