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

=={{header|C sharp|C#}}==

using System.IO;

using System.Collections.Generic;

}

}

<pre>Fido, id=1 is alive

Lupo, id=2 is alive

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>

=={{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|EchoLisp}}==

Our classes will be 'struct' objects, with custom #:tostring procedures, as required. The instances are saved/restored to/from local storage. Serialization is performed by JSONifying the objects. References between instances of struct's are kept in the process. Auto-references and circular references are correctly maintained since EchoLisp version 2.11.

(define (person->string self) (format "%a : person." (person-name self)))

(define (writer->string self) (format "%a: writer of %a."

papa → papa: father of (Simon Elvis).

elvis → Elvis : person.

{{output}}

;; reboot (close the browser window)

; inspect objects.dat :

(define papa (local-get-value 'papa "objects.dat"))

papa → papa: father of (Antoinette papa Elvis).

=={{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>

=={{header|Factor}}==

The <code>serialize</code> vocabulary provides words for serializing and deserializing any Factor object other than continuations. This example demonstrates that objects may be serialized individually, one at a time. In practice, it's probably easier to serialize a collection of objects.

io.files io.files.info kernel prettyprint serialize ;

IN: rosetta-code.object-serialization

! Print out deserialized objects.

{{out}}

<pre>

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:

Example uses [https://hackage.haskell.org/package/binary <tt>binary</tt>] package. Since Haskell doesn't directly support OO-style inheritance, we use a sum type instead:

module Main (main) where

bytes <- ByteString.readFile "objects.dat"

let employees = Binary.decode bytes

=={{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|Julia}}==

abstract type Hello end

sayhello(hh1)

sayhello(hh2)

=={{header|Kotlin}}==

{{trans|Java}}

import java.io.*

System.exit(1)

}

{{out}}

=={{header|Neko}}==

var file_open = $loader.loadprim("std@file_open", 2)

var other = unserialize(buff, $loader)

$print("deserialized:\n")

{{out}}

=={{header|Nim}}==

type

print(t[0])

print(t[1])

{{out}}

<pre>

=={{header|Objeck}}==

bundle Default {

class Thingy {

}

}

=={{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

}

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;;

The module which provides functions to encode arbitrary data structures as sequences of bytes is [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Marshal.html the module Marshal].

All objects (values and references) can be serialized using `fasl-save` (by `fasl-encode`) and deserialized using `fasl-load` (by `fasl-decode`).

$ ol

Welcome to Otus Lisp 1.2,

bye-bye :/

$

=={{header|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].

or whatever you choose to treat as such, is up to you.

<span style="color: #008080;">include</span> <span style="color: #008000;">"builtins/serialize.e"</span>

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fh</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">delete_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"objects.dat"</span><span style="color: #0000FF;">)</span>

{{out}}

=={{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|Racket}}==

The serialization needs to be included with

The rest is covered by the Racket language.

(I have elided the paths in objects.dat -- you wouldn't be able to use them anyway)

;; Object Serialization: Tim Brown, Oct. 2014

(require racket/serialize)

(printf "With siblings:\t~s (he hasn't any)~%" (send cloned-john ->string #:show '(siblings)))

(printf "With children:\t~s~%" (send cloned-john ->string #:show '(children)))

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

# https://docs.raku.org/language/classtut

# https://github.com/teodozjan/perl-store

my $r2 = from_file('objects.dat');

say "Rectangle2 is of type ", $r2.WHAT;

{{out}}

<pre>Create Rectangle1 with area 100

=={{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|Rust}}==

=== Enum ===

Dependencies:

use bincode::{deserialize, serialize};

Ok(())

{{out}}

<pre>Rover is a dog with brown fur

=== Trait ===

Dependencies:

bincode = "1.1.2"

use bincode::{deserialize, serialize};

Ok(())

{{out}}

<pre>Rover is a dog with brown fur

{{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

=={{header|Wren}}==

{{libheader|Wren-json}}

Currently, Wren's only facility for serializing objects is to use the above JSON module. Also this module can only 'stringify' objects of built-in types so we need to provide a suitable string representation for each user-defined class.

import "io" for File, FileFlags

System.print("\nContents of objects.dat are:")

{{out}}

zkl can serialize a "root class" (usually a file but any static (ie parentless) class) to bit bucket (such as File). This is done via reflection. The state of the class(es) are not stored so no image write/read. In the "normal" course of events, this isn't used, programs are compiled on the fly and run. However, there is extensive support to pre-compile and package files into applications or just pre-compile for faster load times (or to create an image that can be compiled into C code (which is done to package the compiler with the VM). When the compiler writes a class or app to a file, the preferred extension is ".zsc", which is what the Import method looks for. But no matter, we have ways ...

class A{ self.println(" constructor"); } // a regular class

class B(A){ // ditto

rc.B().println(); // create a new instance of B

// prints: