Data commit

Task/Object-serialization/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Object_serialization
+note: Object oriented

Task/Object-serialization/00-TASK.txt

@@ -0,0 +1,2 @@
+Create a set of data types based upon [[inheritance]]. Each data type or class should have a print command that displays the contents of an instance of that class to standard output. Create instances of each class in your inheritance hierarchy and display them to standard output. Write each of the objects to a file named ''objects.dat'' in binary form using serialization or marshalling. Read the file ''objects.dat'' and print the contents of each serialized object.
+

Task/Object-serialization/ALGOL-68/object-serialization.alg

@@ -0,0 +1,29 @@
+MODE ENTITY = STRUCT([6]CHAR name, INT creation);
+FORMAT entity repr = $"Name: "g", Created:"g$;
+MODE PERSON = STRUCT(ENTITY entity, STRING email);
+FORMAT person repr = $f(entity repr)", Email: "g$;
+
+PERSON instance1 := PERSON(ENTITY("Cletus", 20080808), "test+1@localhost.localdomain");
+print((name OF entity OF instance1, new line));
+
+ENTITY instance2 := ENTITY("Entity",20111111);
+print((name OF instance2, new line));
+
+FILE target;
+INT errno := open(target, "rows.dat", stand back channel); # open file #
+
+#  Serialise #
+put(target,(instance1, new line, instance2, new line));
+printf(($"Serialised..."l$));
+
+close(target); # flush file stream #
+errno := open(target, "rows.dat", stand back channel); # load again #
+
+# Unserialise #
+PERSON i1;
+ENTITY i2;
+get(target,(i1, new line, i2, new line));
+printf(($"Unserialised..."l$));
+
+printf((person repr, i1, $l$));
+printf((entity repr, i2, $l$))

Task/Object-serialization/Ada/object-serialization-1.ada

@@ -0,0 +1,25 @@
+with Ada.Calendar; use Ada.Calendar;
+
+package Messages is
+   type Message is tagged record
+      Timestamp : Time;
+   end record;
+
+   procedure Print(Item : Message);
+   procedure Display(Item : Message'Class);
+
+   type Sensor_Message is new Message with record
+      Sensor_Id : Integer;
+      Reading : Float;
+   end record;
+
+   procedure Print(Item : Sensor_Message);
+
+   type Control_Message is new Message with record
+      Actuator_Id : Integer;
+      Command     : Float;
+   end record;
+
+   procedure Print(Item : Control_Message);
+
+end Messages;

Task/Object-serialization/Ada/object-serialization-2.ada

@@ -0,0 +1,68 @@
+with Ada.Text_Io; use Ada.Text_Io;
+with Ada.Integer_Text_Io; use Ada.Integer_Text_Io;
+with Ada.Float_Text_IO; use Ada.Float_Text_IO;
+
+package body Messages is
+
+   -----------
+   -- Print --
+   -----------
+
+   procedure Print (Item : Message) is
+      The_Year : Year_Number;
+      The_Month : Month_Number;
+      The_Day   : Day_Number;
+      Seconds   : Day_Duration;
+   begin
+      Split(Date => Item.Timestamp, Year => The_Year,
+         Month => The_Month, Day => The_Day, Seconds => Seconds);
+
+      Put("Time Stamp:");
+      Put(Item => The_Year, Width => 4);
+      Put("-");
+      Put(Item => The_Month, Width => 1);
+      Put("-");
+      Put(Item => The_Day, Width => 1);
+      New_Line;
+   end Print;
+
+   -----------
+   -- Print --
+   -----------
+
+   procedure Print (Item : Sensor_Message) is
+   begin
+      Print(Message(Item));
+      Put("Sensor Id: ");
+      Put(Item => Item.Sensor_Id, Width => 1);
+      New_Line;
+      Put("Reading: ");
+      Put(Item => Item.Reading, Fore => 1, Aft => 4, Exp => 0);
+      New_Line;
+   end Print;
+
+   -----------
+   -- Print --
+   -----------
+
+   procedure Print (Item : Control_Message) is
+   begin
+      Print(Message(Item));
+      Put("Actuator Id: ");
+      Put(Item => Item.Actuator_Id, Width => 1);
+      New_Line;
+      Put("Command: ");
+      Put(Item => Item.Command, Fore => 1, Aft => 4, Exp => 0);
+      New_Line;
+   end Print;
+
+   -------------
+   ---Display --
+   -------------
+
+   procedure Display(Item : Message'Class) is
+   begin
+      Print(Item);
+   end Display;
+
+end Messages;

Task/Object-serialization/Ada/object-serialization-3.ada

@@ -0,0 +1,40 @@
+with Messages; use Messages;
+with Ada.Streams.Stream_Io; use Ada.Streams.Stream_Io;
+with Ada.Calendar; use Ada.Calendar;
+with Ada.Text_Io;
+
+procedure Streams_Example is
+   S1 : Sensor_Message;
+   M1 : Message;
+   C1 : Control_Message;
+   Now : Time := Clock;
+   The_File : Ada.Streams.Stream_Io.File_Type;
+   The_Stream : Ada.Streams.Stream_IO.Stream_Access;
+begin
+   S1 := (Now, 1234, 0.025);
+   M1.Timestamp := Now;
+   C1 := (Now, 15, 0.334);
+   Display(S1);
+   Display(M1);
+   Display(C1);
+   begin
+      Open(File => The_File, Mode => Out_File,
+         Name => "Messages.dat");
+   exception
+      when others =>
+         Create(File => The_File, Name => "Messages.dat");
+   end;
+   The_Stream := Stream(The_File);
+   Sensor_Message'Class'Output(The_Stream, S1);
+   Message'Class'Output(The_Stream, M1);
+   Control_Message'Class'Output(The_Stream, C1);
+   Close(The_File);
+   Open(File => The_File, Mode => In_File,
+      Name => "Messages.dat");
+   The_Stream := Stream(The_File);
+   Ada.Text_Io.New_Line(2);
+   while not End_Of_File(The_File) loop
+      Display(Message'Class'Input(The_Stream));
+   end loop;
+   Close(The_File);
+end Streams_Example;

Task/Object-serialization/C++/object-serialization.cpp

@@ -0,0 +1,118 @@
+#include <string>
+#include <fstream>
+#include <boost/serialization/string.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <iostream>
+
+class Employee {
+public :
+   Employee( ) { }
+
+   Employee ( const std::string &dep , const std::string &namen )
+      : department( dep ) , name( namen ) {
+	 my_id = count++ ;
+      }
+
+   std::string getName( ) const {
+      return name ;
+   }
+
+   std::string getDepartment( ) const {
+      return department ;
+   }
+
+   int getId( ) const {
+      return my_id ;
+   }
+
+   void setDepartment( const std::string &dep ) {
+      department.assign( dep ) ;
+   }
+
+   virtual void print( ) {
+      std::cout << "Name: " << name << '\n' ;
+      std::cout << "Id: " << my_id << '\n' ;
+      std::cout << "Department: " << department << '\n' ;
+   }
+
+   virtual ~Employee( ) { }
+   static int count ;
+private :
+   std::string name ;
+   std::string department ;
+   int my_id ;
+   friend class boost::serialization::access ;
+
+   template <class Archive>
+      void serialize( Archive &ar, const unsigned int version ) {
+	 ar & my_id ;
+	 ar & name ;
+	 ar & department ;
+      }
+
+} ;
+
+class Worker : public Employee {
+public :
+   Worker( const std::string & dep, const std::string &namen ,
+	 double hourlyPay ) : Employee( dep , namen ) , salary( hourlyPay) { }
+
+   Worker( ) { }
+
+   double getSalary( ) {
+      return salary ;
+   }
+
+   void setSalary( double pay ) {
+      if ( pay > 0 )
+	 salary = pay ;
+   }
+
+   virtual void print( ) {
+      Employee::print( ) ;
+      std::cout << "wage per hour: " << salary << '\n' ;
+   }
+private :
+   double salary ;
+   friend class boost::serialization::access ;
+   template <class Archive>
+      void serialize ( Archive & ar, const unsigned int version ) {
+	 ar & boost::serialization::base_object<Employee>( *this ) ;
+	 ar & salary ;
+      }
+} ;
+
+int Employee::count = 0 ;
+
+int main( ) {
+   std::ofstream storefile( "/home/ulrich/objects.dat"  ) ; //creating objects of base class
+   const Employee emp1( "maintenance" , "Fritz Schmalstieg"  ) ;
+   const Employee emp2( "maintenance" , "John Berry" ) ;
+   const Employee emp3( "repair" , "Pawel Lichatschow" ) ;
+   const Employee emp4( "IT" , "Marian Niculescu" ) ;
+   const Worker worker1( "maintenance" , "Laurent Le Chef" , 20 ) ;//creating objects of derived class
+   const Worker worker2 ( "IT" , "Srinivan Taraman" , 55.35 ) ;
+   boost::archive::text_oarchive oar ( storefile ) ;//starting serialization into designated file
+   oar << emp1 ;
+   oar << emp2 ;
+   oar << emp3 ;
+   oar << emp4 ;
+   oar << worker1 ;
+   oar << worker2 ;
+   storefile.close( ) ;
+   std::cout << "Reading out the data again\n" ;
+   Employee e1 , e2 , e3 , e4 ; //creating instances of base class objects for deserialization
+   Worker w1, w2 ; // same for objects of derived class
+   std::ifstream sourcefile( "/home/ulrich/objects.dat"  ) ;
+   boost::archive::text_iarchive iar( sourcefile ) ;//starting deserialization
+   iar >> e1 >> e2 >> e3 >> e4 ;
+   iar >> w1 >> w2 ;
+   sourcefile.close( ) ;
+   std::cout << "And here are the data after deserialization!( abridged):\n" ;
+   e1.print( ) ;
+   e3.print( ) ;
+   w2.print( ) ;
+   return 0 ;
+}

Task/Object-serialization/C-sharp/object-serialization.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace Object_serialization
+{
+  [Serializable] public class Being
+  {
+    public bool Alive { get; set; }
+  }
+
+  [Serializable] public class Animal: Being
+  {
+    public Animal() { }
+
+    public Animal(long id, string name, bool alive = true)
+    {
+      Id = id;
+      Name = name;
+      Alive = alive;
+    }
+
+    public long Id { get; set; }
+    public string Name { get; set; }
+
+    public void Print() { Console.WriteLine("{0}, id={1} is {2}",
+      Name, Id, Alive ? "alive" : "dead"); }
+  }
+
+
+  internal class Program
+  {
+    private static void Main()
+    {
+      string path =
+        Environment.GetFolderPath(Environment.SpecialFolder.Desktop)+"\\objects.dat";
+
+      var n = new List<Animal>
+              {
+                new Animal(1, "Fido"),
+                new Animal(2, "Lupo"),
+                new Animal(7, "Wanda"),
+                new Animal(3, "Kiki", alive: false)
+              };
+
+      foreach(Animal animal in n)
+        animal.Print();
+
+      using(var stream = new FileStream(path, FileMode.Create, FileAccess.Write))
+        new BinaryFormatter().Serialize(stream, n);
+
+      n.Clear();
+      Console.WriteLine("---------------");
+      List<Animal> m;
+
+      using(var stream = new FileStream(path, FileMode.Open, FileAccess.Read))
+        m = (List<Animal>) new BinaryFormatter().Deserialize(stream);
+
+      foreach(Animal animal in m)
+        animal.Print();
+    }
+  }
+}

Task/Object-serialization/Common-Lisp/object-serialization-1.lisp

@@ -0,0 +1,12 @@
+(defmacro with-serialization-to-file ((stream pathname) &body body)
+  `(with-open-file (,stream ,pathname
+                            :element-type '(unsigned-byte 8)
+                            :direction :output
+                            :if-exists :supersede)
+     ,@body))
+
+(defclass entity ()
+  ((name :initarg :name :initform "Some entity")))
+
+(defclass person (entity)
+  ((name :initarg :name :initform "The Nameless One")))

Task/Object-serialization/Common-Lisp/object-serialization-2.lisp

@@ -0,0 +1,35 @@
+CL-USER> (list (make-instance 'entity)
+               (make-instance 'person))
+
+(#<ENTITY {1004B13141}> #<PERSON {1004B142B1}>)
+CL-USER> (mapc #'describe *)
+#<ENTITY {1004B13141}>
+  [standard-object]
+
+Slots with :INSTANCE allocation:
+  NAME  = "Some entity"
+#<PERSON {1004B142B1}>
+  [standard-object]
+
+Slots with :INSTANCE allocation:
+  NAME  = "The Nameless One"
+(#<ENTITY {1004B13141}> #<PERSON {1004B142B1}>)
+CL-USER> (with-serialization-to-file (stream "/tmp/objects.dat")
+           (cl-serializer:serialize * :output stream)
+           ;; SERIALIZE shows an octet-vector as its return value
+           (values))
+; No value
+CL-USER> (mapc #'describe (with-open-file (stream "/tmp/objects.dat"
+                                                  :element-type '(unsigned-byte 8))
+                            (cl-serializer:deserialize stream)))
+#<ENTITY {1003C12911}>
+  [standard-object]
+
+Slots with :INSTANCE allocation:
+  NAME  = "Some entity"
+#<PERSON {1003C12A81}>
+  [standard-object]
+
+Slots with :INSTANCE allocation:
+  NAME  = "The Nameless One"
+(#<ENTITY {1003C12911}> #<PERSON {1003C12A81}>)

Task/Object-serialization/D/object-serialization.d

@@ -0,0 +1,35 @@
+import test1;
+import std.stdio;
+import std.file;
+class full2:base2 {
+        this(byte[]manip,bool isroot=true) {super(manip,isroot);}
+        this(){super();}
+        void print() {
+                foreach(item;rep) {
+                        writefln(item.i32);
+                }
+        }
+}
+
+void main() {
+        full2 base = new full2();
+        base1 tmp = new base1;
+        tmp.i32 = 34;
+        base.add_rep(tmp);
+        tmp = new base1;
+        tmp.i32 = 32;
+        base.add_rep(tmp);
+        tmp = new base1;
+        tmp.i32 = 33;
+        base.add_rep(tmp);
+        tmp = new base1;
+        tmp.i32 = 36;
+        base.add_rep(tmp);
+        writefln("Input data:");
+        base.print;
+        write("objects.dat",base.Serialize());
+        byte[]filedata = cast(byte[])read("objects.dat");
+        base = new full2(filedata);
+        writefln("Output data:");
+        base.print;
+}

Task/Object-serialization/E/object-serialization-1.e

@@ -0,0 +1,21 @@
+def makeEvent(time :int) {
+    return def event {
+        to __printOn(out) { out.print(`@@$time`) }
+        to __optUncall() { return [makeEvent, "run", [time]] }
+        to getTime() { return time }
+    }
+}
+
+def makeArrival(time :int, what :any, position :int) {
+    return def arrival extends makeEvent(time) {
+        to __printOn(out) {
+            out.print(`$what to $position $super`)
+        }
+        to __optUncall() {
+            return [makeArrival, "run", [time, what, position]]
+        }
+
+        to getWhat() { return what }
+        to getPosition() { return position }
+    }
+}

Task/Object-serialization/E/object-serialization-2.e

@@ -0,0 +1,3 @@
+def surgeon := <import:org.erights.e.elib.serial.makeSurgeon>().diverge()
+surgeon.addExit(makeEvent, "makeEvent")
+surgeon.addExit(makeArrival, "makeArrival")

Task/Object-serialization/E/object-serialization-3.e

@@ -0,0 +1,6 @@
+def objs := [makeEvent(timer.now()),
+             makeArrival(timer.now(), "Smith", 7)]
+
+stdout.println(objs)
+<file:objects.dat>.setBytes(surgeon.serialize(objs))
+stdout.println(surgeon.unserialize(<file:objects.dat>.getBytes()))

Task/Object-serialization/EchoLisp/object-serialization-1.l

@@ -0,0 +1,31 @@
+(define (person->string self) (format "%a : person." (person-name self)))
+(define (writer->string self) (format "%a:  writer of %a."
+			(person-name self)
+			(writer-books self)))
+(define  (father->string self) (format "%a: father of %a."
+			(person-name self)
+			(map person-name (father-children self))))
+			
+; 'classes' definition, with inheritance.
+; a writer is a person, too.
+(struct person (name)  #:tostring person->string)
+(struct writer person (books) #:tostring writer->string)
+(struct father person (children)  #:tostring father->string)
+
+(define simon (writer "Simon" '(my-life my-wife my-bike)))
+(define elvis (person "Elvis"))
+(define papa (father "papa" (list simon elvis)))
+
+(local-put-value 'simon simon "objects.dat")
+📕 local-db: local-put:unknown store : "objects.dat"
+;; forgot to create the store. Create it :
+(local-make-store "objects.dat") → "objects.dat"
+
+(local-put-value 'simon simon "objects.dat")
+(local-put-value 'elvis elvis "objects.dat")
+(local-put-value 'papa papa   "objects.dat")
+
+;; inspect
+simon → Simon: writer of (my-life my-wife my-bike).
+papa → papa: father of (Simon Elvis).
+elvis → Elvis : person.

Task/Object-serialization/EchoLisp/object-serialization-2.l

@@ -0,0 +1,28 @@
+;; reboot (close the browser window)
+; inspect objects.dat :
+(local-keys 'objects.dat) → ("elvis" "papa" "simon")
+
+(define simon (local-get-value 'simon "objects.dat"))
+(define elvis (local-get-value 'elvis "objects.dat"))
+(define papa (local-get-value 'papa "objects.dat"))
+
+; data are restored
+simon → Simon: writer of (my-life my-wife my-bike).
+papa → papa: father of (Simon Elvis).
+
+;; check if references (pointers) are restored
+(set-writer-name! simon "Antoinette") → "Antoinette"
+simon→ Antoinette: writer of (my-life my-wife my-bike).
+
+;; inspect
+papa → papa: father of (Antoinette Elvis). ; YES 😳 !
+
+;; - Self-referencing  (EchoLisp version 2.11)
+;; add 'papa' to the chidren of 'papa' - whatever this means - and print it :
+(set-father-children! papa (list simon papa elvis))
+papa → papa: father of (Antoinette papa Elvis).
+
+; save/restore
+(local-put-value 'papa papa "objects.dat")
+(define papa (local-get-value 'papa "objects.dat"))
+papa → papa: father of (Antoinette papa Elvis).

Task/Object-serialization/Erlang/object-serialization.erl

@@ -0,0 +1,28 @@
+-module( object_serialization ).
+
+-export( [task/0] ).
+
+-record( entity, {name, date} ).
+-record( person, {entity, email} ).
+
+task() ->
+	Person = #person{entity=#entity{name="Cletus", date=20080808}, email="test+1@localhost.localdomain"},
+	print( Person ),
+	Entity = #entity{name="Entity", date=20111111},
+	print( Entity ),
+	ok = file:write_file( "objects.dat", erlang:term_to_binary([Person, Entity]) ),
+	{ok, Binary} =  file:read_file( "objects.dat" ),
+	[New_person, New_entity] = erlang:binary_to_term( Binary ),
+	io:fwrite( "Deserialized\n" ),
+	print( New_person ),
+	print( New_entity ).
+	
+
+
+print( #entity{name=Name, date=Date} ) ->
+	io:fwrite( "Entity: " ),
+	io:fwrite( "name: ~p, date: ~p~n", [Name, Date] );
+print( #person{entity=Entity, email=Email} ) ->
+	io:fwrite( "Person: " ),
+	print( Entity ),
+	io:fwrite( "\temail: ~p~n", [Email] ).

Task/Object-serialization/Factor/object-serialization.factor

@@ -0,0 +1,45 @@
+USING: accessors combinators.extras io io.encodings.binary
+io.files io.files.info kernel prettyprint serialize ;
+IN: rosetta-code.object-serialization
+
+! Define two classes, item and armor. armor is a subclass of
+! item.
+
+TUPLE: item name value ;
+TUPLE: armor < item physical-resistance fire-resistance ;
+
+! Define boa constructors for both classes using C: shorthand.
+! boa means By Order of Arguments, and yes, this is a pun on boa
+! constrictors.
+
+C: <item> item
+C: <armor> armor
+
+! Create three example items and print them out
+! non-destructively.
+
+"Fish scales" 0.05 <item>
+"Gold piece" 1 <item>
+"Breastplate of Ashannar" 50,000 55 30 <armor>
+[ [ . ] keep ] tri@ nl
+
+! Serialize the three objects to a binary file named
+! objects.dat.
+
+"Serializing objects to objects.dat . . . " print
+"objects.dat" binary [ [ serialize ] tri@ ] with-file-writer
+
+! Check that objects.dat exists.
+
+"objects.dat exists? " write "objects.dat" exists? .
+"Size on disk: " write "objects.dat" file-info size>> pprint
+" bytes" print nl
+
+! Deserialize three objects from objects.dat.
+
+"Deserializing objects from objects.dat . . . " print nl
+"objects.dat" binary [ [ deserialize ] thrice ] with-file-reader
+
+! Print out deserialized objects.
+
+[ . ] tri@

Task/Object-serialization/Go/object-serialization.go

@@ -0,0 +1,154 @@
+package main
+
+import (
+    "encoding/gob"
+    "fmt"
+    "os"
+)
+
+type printable interface {
+    print()
+}
+
+func main() {
+    // create instances
+    animals := []printable{
+        &Animal{Alive: true},
+        &Cat{},
+        &Lab{
+            Dog:   Dog{Animal: Animal{Alive: true}},
+            Color: "yellow",
+        },
+        &Collie{Dog: Dog{
+            Animal:           Animal{Alive: true},
+            ObedienceTrained: true,
+        }},
+    }
+
+    // display
+    fmt.Println("created:")
+    for _, a := range animals {
+        a.print()
+    }
+
+    // serialize
+    f, err := os.Create("objects.dat")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    for _, a := range animals {
+        gob.Register(a)
+    }
+    err = gob.NewEncoder(f).Encode(animals)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    f.Close()
+
+    // read
+    f, err = os.Open("objects.dat")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    var clones []printable
+    gob.NewDecoder(f).Decode(&clones)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+
+    // display
+    fmt.Println("\nloaded from objects.dat:")
+    for _, c := range clones {
+        c.print()
+    }
+}
+
+type Animal struct {
+    Alive bool
+}
+
+func (a *Animal) print() {
+    if a.Alive {
+        fmt.Println("   live animal, unspecified type")
+    } else {
+        fmt.Println("   dead animal, unspecified type")
+    }
+}
+
+type Dog struct {
+    Animal
+    ObedienceTrained bool
+}
+
+func (d *Dog) print() {
+    switch {
+    case !d.Alive:
+        fmt.Println("   dead dog")
+    case d.ObedienceTrained:
+        fmt.Println("   trained dog")
+    default:
+        fmt.Println("   dog, not trained")
+    }
+}
+
+type Cat struct {
+    Animal
+    LitterBoxTrained bool
+}
+
+func (c *Cat) print() {
+    switch {
+    case !c.Alive:
+        fmt.Println("   dead cat")
+    case c.LitterBoxTrained:
+        fmt.Println("   litter box trained cat")
+    default:
+        fmt.Println("   cat, not litter box trained")
+    }
+}
+
+type Lab struct {
+    Dog
+    Color string
+}
+
+func (l *Lab) print() {
+    var r string
+    if l.Color == "" {
+        r = "lab, color unspecified"
+    } else {
+        r = l.Color + " lab"
+    }
+    switch {
+    case !l.Alive:
+        fmt.Println("   dead", r)
+    case l.ObedienceTrained:
+        fmt.Println("   trained", r)
+    default:
+        fmt.Printf("   %s, not trained\n", r)
+    }
+}
+
+type Collie struct {
+    Dog
+    CatchesFrisbee bool
+}
+
+func (c *Collie) print() {
+    switch {
+    case !c.Alive:
+        fmt.Println("   dead collie")
+    case c.ObedienceTrained && c.CatchesFrisbee:
+        fmt.Println("   trained collie, catches frisbee")
+    case c.ObedienceTrained && !c.CatchesFrisbee:
+        fmt.Println("   trained collie, but doesn't catch frisbee")
+    case !c.ObedienceTrained && c.CatchesFrisbee:
+        fmt.Println("   collie, not trained, but catches frisbee")
+    case !c.ObedienceTrained && !c.CatchesFrisbee:
+        fmt.Println("   collie, not trained, doesn't catch frisbee")
+    }
+}

Task/Object-serialization/Groovy/object-serialization-1.groovy

@@ -0,0 +1,11 @@
+class Entity implements Serializable {
+    static final serialVersionUID = 3504465751164822571L
+    String name = 'Thingamabob'
+    public String toString() { return name }
+}
+
+class Person extends Entity implements Serializable {
+    static final serialVersionUID = -9170445713373959735L
+    Person() { name = 'Clement' }
+    Person(name) { this.name = name }
+}

Task/Object-serialization/Groovy/object-serialization-2.groovy

@@ -0,0 +1,19 @@
+File objectStore = new File('objectStore.ser')
+if (objectStore.exists()) { objectStore.delete() }
+assert ! objectStore.exists()
+def os
+try {
+    os = objectStore.newObjectOutputStream()
+    os << new Person()
+    os << 10.5
+    os << new Person('Cletus')
+    os << new Date()
+    os << new Person('Pious')
+    os << java.awt.Color.RED
+    os << new Person('Linus')
+    os << 'just random garbage'
+    os << new Person('Lucy')
+    os << ['lists', 'are', 'serializable']
+    os << new Person('Schroeder')
+} catch (e) { throw new Exception(e) } finally { os?.close() }
+assert objectStore.exists()

Task/Object-serialization/Groovy/object-serialization-3.groovy

@@ -0,0 +1,8 @@
+def is
+try {
+    is = objectStore.newObjectInputStream(this.class.classLoader)
+    is.eachObject { println it }
+} catch (e) { throw new Exception(e) } finally { is?.close() }
+
+objectStore.delete()
+assert ! objectStore.exists()

Task/Object-serialization/Haskell/object-serialization.hs

@@ -0,0 +1,25 @@
+{-# LANGUAGE DeriveGeneric #-}
+
+module Main (main) where
+
+import qualified Data.ByteString.Lazy as ByteString (readFile, writeFile)
+import           Data.Binary (Binary)
+import qualified Data.Binary as Binary (decode, encode)
+import           GHC.Generics (Generic)
+
+data Employee =
+    Manager String String
+    | IndividualContributor String String
+    deriving (Generic, Show)
+instance Binary Employee
+
+main :: IO ()
+main = do
+    ByteString.writeFile "objects.dat" $ Binary.encode
+        [ IndividualContributor "John Doe" "Sales"
+        , Manager "Jane Doe" "Engineering"
+        ]
+
+    bytes <- ByteString.readFile "objects.dat"
+    let employees = Binary.decode bytes
+    print (employees :: [Employee])

Task/Object-serialization/J/object-serialization-1.j

@@ -0,0 +1,41 @@
+lin_z_=:5!:5
+serializeObject=:3 :0
+  p=. copath y
+  d=. ;LF;"1(,'=:';lin__y)"0 nl__y i.4
+  '(',(5!:5<'p'),')(copath[cocurrent@])cocreate ''''',,d,LF
+)
+
+deserializeObject=:3 :0
+  o=.conl 1
+  0!:100 y
+  (conl 1)-.o
+)
+
+coclass'room'
+  create=:3 :'size=:y'
+  print=:3 :'''room size '',":size'
+
+coclass'kitchen'
+  coinsert'room'
+  print=:3 :'''kitchen size '',":size'
+
+coclass'kitchenWithSink'
+  coinsert'kitchen'
+  print=:3 :'''kitchen with sink size '',":size'
+
+cocurrent'base'
+
+R=:'small' conew 'room'
+K=:'medium' conew 'kitchen'
+S=:'large' conew 'kitchenWithSink'
+print__R''
+print__K''
+print__S''
+
+
+(;<@serializeObject"0 R,K,S) 1!:2 <'objects.dat'
+
+'r1 k1 s1'=: <"0 deserializeObject 1!:1<'objects.dat'
+print__r1''
+print__k1''
+print__s1''

Task/Object-serialization/J/object-serialization-2.j

@@ -0,0 +1,17 @@
+   print__R''
+room size small
+   print__K''
+kitchen size medium
+   print__S''
+kitchen with sink size large
+
+
+   (;<@serializeObject"0 R,K,S) 1!:2 <'objects.dat'
+
+   'r1 k1 s1'=: <"0 deserializeObject 1!:1<'objects.dat'
+   print__r1''
+room size small
+   print__k1''
+kitchen size medium
+   print__s1''
+kitchen with sink size large

Task/Object-serialization/Java/object-serialization.java

@@ -0,0 +1,60 @@
+import java.io.*;
+
+// classes must implement java.io.Serializable in order to be serializable
+class Entity implements Serializable {
+    // it is recommended to hard-code serialVersionUID so changes to class
+    // will not invalidate previously serialized objects
+    static final long serialVersionUID = 3504465751164822571L;
+    String name = "Entity";
+    public String toString() { return name; }
+}
+
+class Person extends Entity implements Serializable {
+    static final long serialVersionUID = -9170445713373959735L;
+    Person() { name = "Cletus"; }
+}
+
+public class SerializationTest {
+    public static void main(String[] args) {
+        Person instance1 = new Person();
+        System.out.println(instance1);
+
+        Entity instance2 = new Entity();
+        System.out.println(instance2);
+
+        // Serialize
+        try {
+            ObjectOutput out = new ObjectOutputStream(new FileOutputStream("objects.dat")); // open ObjectOutputStream
+
+            out.writeObject(instance1); // serialize "instance1" and "instance2" to "out"
+            out.writeObject(instance2);
+            out.close();
+            System.out.println("Serialized...");
+        } catch (IOException e) {
+            System.err.println("Something screwed up while serializing");
+            e.printStackTrace();
+            System.exit(1);
+        }
+
+        // Deserialize
+        try {
+            ObjectInput in = new ObjectInputStream(new FileInputStream("objects.dat")); // open ObjectInputStream
+
+            Object readObject1 = in.readObject(); // read two objects from "in"
+            Object readObject2 = in.readObject(); // you may want to cast them to the appropriate types
+            in.close();
+            System.out.println("Deserialized...");
+
+            System.out.println(readObject1);
+            System.out.println(readObject2);
+        } catch (IOException e) {
+            System.err.println("Something screwed up while deserializing");
+            e.printStackTrace();
+            System.exit(1);
+        } catch (ClassNotFoundException e) {
+            System.err.println("Unknown class for deserialized object");
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+}

Task/Object-serialization/Julia/object-serialization.julia

@@ -0,0 +1,37 @@
+abstract type Hello end
+
+struct HelloWorld <: Hello
+    name::String
+    HelloWorld(s) = new(s)
+end
+
+struct HelloTime <: Hello
+    name::String
+    tnew::DateTime
+    HelloTime(s) = new(s, now())
+end
+
+sayhello(hlo) = println("Hello to this world, $(hlo.name)!")
+
+sayhello(hlo::HelloTime) = println("It is now $(now()). Hello from back in $(hlo.tnew), $(hlo.name)!")
+
+h1 = HelloWorld("world")
+h2 = HelloTime("new world")
+
+sayhello(h1)
+sayhello(h2)
+
+fh = open("objects.dat", "w")
+serialize(fh, h1)
+serialize(fh,h2)
+close(fh)
+
+sleep(10)
+
+fh = open("objects.dat", "r")
+hh1 = deserialize(fh)
+hh2 = deserialize(fh)
+close(fh)
+
+sayhello(hh1)
+sayhello(hh2)

Task/Object-serialization/Kotlin/object-serialization.kotlin

@@ -0,0 +1,57 @@
+// version 1.2.0
+
+import java.io.*
+
+open class Entity(val name: String = "Entity"): Serializable {
+    override fun toString() = name
+
+    companion object {
+        val serialVersionUID = 3504465751164822571L
+    }
+}
+
+class Person(name: String = "Brian"): Entity(name), Serializable {
+    companion object {
+        val serialVersionUID = -9170445713373959735L
+    }
+}
+
+fun main(args: Array<String>) {
+    val instance1 = Person()
+    println(instance1)
+
+    val instance2 = Entity()
+    println(instance2)
+
+    // serialize
+    try {
+        val out = ObjectOutputStream(FileOutputStream("objects.dat"))
+        out.writeObject(instance1)
+        out.writeObject(instance2)
+        out.close()
+        println("Serialized...")
+    }
+    catch (e: IOException) {
+        println("Error occurred whilst serializing")
+        System.exit(1)
+    }
+
+    // deserialize
+    try {
+        val inp = ObjectInputStream(FileInputStream("objects.dat"))
+        val readObject1 = inp.readObject()
+        val readObject2 = inp.readObject()
+        inp.close()
+        println("Deserialized...")
+        println(readObject1)
+        println(readObject2)
+    }
+    catch (e: IOException) {
+        println("Error occurred whilst deserializing")
+        System.exit(1)
+    }
+    catch (e: ClassNotFoundException) {
+        println("Unknown class for deserialized object")
+        System.exit(1)
+    }
+}

Task/Object-serialization/Neko/object-serialization.neko

@@ -0,0 +1,41 @@
+/* Object serialization, in Neko */
+
+var file_open = $loader.loadprim("std@file_open", 2)
+var file_write = $loader.loadprim("std@file_write", 4)
+var file_read = $loader.loadprim("std@file_read", 4)
+var file_close = $loader.loadprim("std@file_close", 1)
+
+var serialize = $loader.loadprim("std@serialize", 1)
+var unserialize = $loader.loadprim("std@unserialize", 2)
+
+/* Inheritance by prototype */
+proto = $new(null)
+proto.print = function () { $print(this, "\n") }
+
+obj = $new(null)
+obj.msg = "Hello"
+obj.dest = $array("Town", "Country", "World")
+
+$objsetproto(obj, proto)
+$print("Original:\n")
+obj.print()
+
+/* Serialize the object */
+var thing = serialize(obj)
+var len = $ssize(thing)
+
+/* To disk */
+var f = file_open("object-serialization.bin", "w")
+file_write(f, thing, 0, len)
+file_close(f)
+
+/* Load the binary data into a new string space */
+f = file_open("object-serialization.bin", "r")
+var buff = $smake(len)
+file_read(f, buff, 0, len)
+file_close(f)
+
+/* Unserialize the object into a new variable */
+var other = unserialize(buff, $loader)
+$print("deserialized:\n")
+other.print()

Task/Object-serialization/Nim/object-serialization.nim

@@ -0,0 +1,25 @@
+import marshal, streams
+
+type
+  Base = object of RootObj
+    name: string
+  Descendant = object of Base
+proc newBase(): Base = Base(name: "base")
+proc newDescendant(): Descendant = Descendant(name: "descend")
+proc print(obj: Base) =
+  echo(obj.name)
+
+var
+  base = newBase()
+  descendant = newDescendant()
+print(base)
+print(descendant)
+
+var strm = newFileStream("objects.dat", fmWrite)
+store(strm, (base, descendant))
+strm.close()
+
+var t: (Base, Descendant)
+load(newFileStream("objects.dat", fmRead), t)
+print(t[0])
+print(t[1])

Task/Object-serialization/OCaml/object-serialization.ocaml

@@ -0,0 +1,23 @@
+type entity = { name : string }
+
+let create_entity () = { name = "Entity" }
+let print_entity x = print_endline x.name
+let create_person () = { name = "Cletus" }
+
+let instance1 = create_person ()
+let instance2 = create_entity ()
+
+(* Serialize *)
+let out_chan = open_out_bin "objects.dat";;
+output_value out_chan instance1;;
+output_value out_chan instance2;;
+close_out out_chan;;
+
+(* Deserialize *)
+let in_chan = open_in_bin "objects.dat";;
+let result1 : entity = input_value in_chan;;
+let result2 : entity = input_value in_chan;;
+close_in in_chan;;
+
+print_entity result1;;
+print_entity result2;;

Task/Object-serialization/Objeck/object-serialization.objeck

@@ -0,0 +1,50 @@
+bundle Default {
+  class Thingy {
+    @id : Int;
+
+    New(id : Int) {
+      @id := id;
+    }
+
+    method : public : Print() ~ Nil {
+      @id->PrintLine();
+    }
+  }
+
+  class Person from Thingy {
+    @name : String;
+
+    New(id : Int, name : String) {
+      Parent(id);
+      @name := name;
+    }
+
+    method : public : Print() ~ Nil {
+      @id->PrintLine();
+      @name->PrintLine();
+    }
+  }
+
+  class Serial {
+    function : Main(args : String[]) ~ Nil {
+      t := Thingy->New(7);
+      p := Person->New(13, "Bush");
+
+      s := IO.Serializer->New();
+      s->Write(t->As(Base));
+      s->Write(p->As(Base));
+
+      writer := IO.FileWriter->New("objects.dat");
+      writer->WriteBuffer(s->Serialize());
+      writer->Close();
+
+      buffer := IO.FileReader->ReadBinaryFile("objects.dat");
+      d := IO.Deserializer->New(buffer);
+
+      t2 := d->ReadObject()->As(Thingy);
+      t2->Print();
+      p2 := d->ReadObject()->As(Person);
+      p2->Print();
+    }
+  }
+}

Task/Object-serialization/Objective-C/object-serialization.m

@@ -0,0 +1,156 @@
+#import <Foundation/Foundation.h>
+
+// a fantasy two level hierarchy
+@interface Animal : NSObject <NSCoding>
+{
+  NSString *animalName;
+  int numberOfLegs;
+}
+- (instancetype) initWithName: (NSString*)name andLegs: (NSInteger)legs;
+- (void) dump;
+@end
+
+@implementation Animal
+- (instancetype) initWithName: (NSString*)name andLegs: (NSInteger)legs
+{
+  if ((self = [super init])) {
+    animalName = name;
+    numberOfLegs = legs;
+  }
+  return self;
+}
+- (void) dump
+{
+  NSLog(@"%@ has %d legs", animalName, numberOfLegs);
+}
+// ========
+- (void) encodeWithCoder: (NSCoder*)coder
+{
+  [coder encodeObject: animalName forKey: @"Animal.name"];
+  [coder encodeInt: numberOfLegs forKey: @"Animal.legs"];
+}
+- (instancetype) initWithCoder: (NSCoder*)coder
+{
+  if ((self = [super init])) {
+    animalName = [coder decodeObjectForKey: @"Animal.name"];
+    numberOfLegs = [coder decodeIntForKey: @"Animal.legs"];
+  }
+  return self;
+}
+@end
+
+@interface Mammal : Animal <NSCoding>
+{
+  BOOL hasFur;
+  NSMutableArray *eatenList;
+}
+- (instancetype) initWithName: (NSString*)name hasFur: (BOOL)fur;
+- (void) addEatenThing: (NSString*)thing;
+@end
+
+@implementation Mammal
+- (instancetype) init
+{
+  if ((self = [super init])) {
+    hasFur = NO;
+    eatenList = [[NSMutableArray alloc] initWithCapacity: 10];
+  }
+  return self;
+}
+- (instancetype) initWithName: (NSString*)name hasFur: (BOOL)fur
+{
+  if ((self = [super initWithName: name andLegs: 4])) {
+    hasFur = fur;
+    eatenList = [[NSMutableArray alloc] initWithCapacity: 10];
+  }
+  return self;
+}
+- (void) addEatenThing: (NSString*)thing
+{
+  [eatenList addObject: thing];
+}
+- (void) dump
+{
+  [super dump];
+  NSLog(@"has fur? %@", (hasFur) ? @"yes" : @"no" );
+  NSLog(@"it has eaten %d things:", [eatenList count]);
+  for ( id element in eatenList )
+    NSLog(@"it has eaten a %@", element);
+  NSLog(@"end of eaten things list");
+}
+// ========= de/archiving
+- (void) encodeWithCoder: (NSCoder*)coder
+{
+  [super encodeWithCoder: coder];
+  [coder encodeBool: numberOfLegs forKey: @"Mammal.hasFur"];
+  [coder encodeObject: eatenList forKey: @"Mammal.eaten"];
+}
+- (instancetype) initWithCoder: (NSCoder*)coder
+{
+  if ((self = [super initWithCoder: coder])) {
+    hasFur = [coder decodeBoolForKey: @"Mammal.hasFur"];
+    eatenList = [coder decodeObjectForKey: @"Mammal.eaten"];
+  }
+  return self;
+}
+@end
+
+
+int main()
+{
+  @autoreleasepool {
+
+    // let us create a fantasy animal
+    Animal *anAnimal = [[Animal alloc]
+	         initWithName: @"Eptohippos"
+	         andLegs: 7
+	        ];
+    // for some reason an Eptohippos is not an horse with 7 legs,
+    // and it is not a mammal, of course...
+
+    // let us create a fantasy mammal (which is an animal too)
+    Mammal *aMammal = [[Mammal alloc]
+	        initWithName: @"Mammaluc"
+	        hasFur: YES
+	       ];
+    // let us add some eaten stuff...
+    [aMammal addEatenThing: @"lamb"];
+    [aMammal addEatenThing: @"table"];
+    [aMammal addEatenThing: @"web page"];
+
+    // dump anAnimal
+    NSLog(@"----- original Animal -----");
+    [anAnimal dump];
+
+    // dump aMammal...
+    NSLog(@"----- original Mammal -----");
+    [aMammal dump];
+
+    // now let us store the objects...
+    NSMutableData *data = [[NSMutableData alloc] init];
+    NSKeyedArchiver *arch = [[NSKeyedArchiver alloc]
+			      initForWritingWithMutableData: data];
+    [arch encodeObject: anAnimal forKey: @"Eptohippos"];
+    [arch encodeObject: aMammal forKey: @"Mammaluc"];
+    [arch finishEncoding];
+    [data writeToFile: @"objects.dat" atomically: YES];
+
+    // now we want to retrieve the saved objects...
+    NSData *ldata = [[NSData alloc]
+		       initWithContentsOfFile: @"objects.dat"];
+    NSKeyedUnarchived *darch = [[NSKeyedUnarchiver alloc]
+	                         initForReadingWithData: ldata];
+    Animal *archivedAnimal = [darch decodeObjectForKey: @"Eptohippos"];
+    Mammal *archivedMammal = [darch decodeObjectForKey: @"Mammaluc"];
+    [darch finishDecoding];
+
+    // now let's dump/print the objects...
+    NSLog(@"\n");
+    NSLog(@"----- the archived Animal -----");
+    [archivedAnimal dump];
+    NSLog(@"----- the archived Mammal -----");
+    [archivedMammal dump];
+
+  }
+  return EXIT_SUCCESS;
+}

Task/Object-serialization/Ol/object-serialization.ol

@@ -0,0 +1,38 @@
+$ ol
+Welcome to Otus Lisp 1.2,
+type ',help' to help, ',quit' to end session.
+> (define Object (tuple
+   '(1 2 3 4)  ; list
+   #(4 3 2 1)  ; bytevector
+   "hello"     ; ansi string
+   "こんにちは"  ; unicode string
+   (list->ff '(; associative array
+      (1 . 123456)
+      (2 . second)
+      (3 . "-th-")))
+   {(4 . 'sym) ; alternatively declared..
+    (5 . +)}   ; ..associative array
+   #false      ; value
+   -123        ; short number
+   123456789012345678901234567890123456789  ; long number
+)
+;; Defined Object
+#((1 2 3 4) #(4 3 2 1) hello こんにちは #ff((1 . 123456) (2 . second) (3 . -th-))
+#ff((4 . sym) (5 . #<function>)) #false -123
+123456789012345678901234567890123456789)
+
+> (fasl-save Object "/tmp/object.bin")
+#true
+
+> (define New (fasl-load "/tmp/object.bin" #false))
+;; Defined New
+#((1 2 3 4) #(4 3 2 1) hello こんにちは #ff((1 . 123456) (2 . second) (3 . -th-))
+#ff((4 . sym) (5 . #<function>)) #false -123
+123456789012345678901234567890123456789)
+
+> (equal? Object New)
+#true
+
+> ,quit
+bye-bye :/
+$

Task/Object-serialization/PHP/object-serialization.php

@@ -0,0 +1,2 @@
+$myObj = new Object();
+$serializedObj = serialize($myObj);

Task/Object-serialization/Perl/object-serialization-1.pl

@@ -0,0 +1,35 @@
+{
+    package Greeting;
+    sub new {
+        my $v = "Hello world!\n";
+        bless \$v, shift;
+    };
+    sub stringify {
+        ${shift()};
+    };
+};
+{
+    package Son::of::Greeting;
+    use base qw(Greeting); # inherit methods
+    sub new { # overwrite method of super class
+        my $v = "Hello world from Junior!\n";
+        bless \$v, shift;
+    };
+};
+{
+    use Storable qw(store retrieve);
+    package main;
+    my $g1 = Greeting->new;
+    my $s1 = Son::of::Greeting->new;
+    print $g1->stringify;
+    print $s1->stringify;
+
+    store $g1, 'objects.dat';
+    my $g2 = retrieve 'objects.dat';
+
+    store $s1, 'objects.dat';
+    my $s2 = retrieve 'objects.dat';
+
+    print $g2->stringify;
+    print $s2->stringify;
+};

Task/Object-serialization/Perl/object-serialization-2.pl

@@ -0,0 +1,25 @@
+use MooseX::Declare;
+
+class Greeting {
+    use MooseX::Storage;
+    with Storage('format' => 'JSON', io => 'File');
+    has string => (is => 'ro', default => "Hello world!\n");
+}
+class Son::Of::Greeting extends Greeting {
+    has string => (is => 'ro', default => "Hello from Junior!\n");
+}
+
+my $g1 = Greeting->new;
+my $s1 = Son::Of::Greeting->new;
+
+print $g1->string;
+print $s1->string;
+
+$g1->store('object1.json');
+my $g2 = Greeting->load('object1.json');
+
+$s1->store('object2.json');
+my $s2 = Son::Of::Greeting->load('object2.json');
+
+print $g2->string;
+print $s2->string;

Task/Object-serialization/Phix/object-serialization.phix

@@ -0,0 +1,39 @@
+-->
+ <span style="color: #008080;">include</span> <span style="color: #008000;">"builtins/serialize.e"</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">randobj</span><span style="color: #0000FF;">()</span>
+ <span style="color: #000080;font-style:italic;">-- test function (generate some random garbage)</span>
+     <span style="color: #004080;">object</span> <span style="color: #000000;">res</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)<=</span><span style="color: #000000;">3</span> <span style="color: #008080;">then</span>     <span style="color: #000080;font-style:italic;">-- make sequence[1..3]</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+             <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">randobj</span><span style="color: #0000FF;">())</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">elsif</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)<=</span><span style="color: #000000;">3</span> <span style="color: #008080;">then</span>  <span style="color: #000080;font-style:italic;">-- make string</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'A'</span><span style="color: #0000FF;">+</span><span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
+     <span style="color: #008080;">else</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">rand</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span>    <span style="color: #000080;font-style:italic;">-- half int/half float</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">object</span> <span style="color: #000000;">o1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">randobj</span><span style="color: #0000FF;">(),</span>
+        <span style="color: #000000;">o2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">randobj</span><span style="color: #0000FF;">(),</span>
+        <span style="color: #000000;">o3</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">randobj</span><span style="color: #0000FF;">()</span>
+
+ <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">({</span><span style="color: #000000;">o1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">o2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">o3</span><span style="color: #0000FF;">},{</span><span style="color: #000000;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">fh</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"objects.dat"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"wb"</span><span style="color: #0000FF;">)</span>
+ <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fh</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">serialize</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o1</span><span style="color: #0000FF;">))</span>
+ <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fh</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">serialize</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o2</span><span style="color: #0000FF;">))</span>
+ <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fh</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">serialize</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o3</span><span style="color: #0000FF;">))</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: #008000;">"==="</span>
+
+ <span style="color: #000000;">fh</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"objects.dat"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"rb"</span><span style="color: #0000FF;">)</span>
+ <span style="color: #0000FF;">?</span><span style="color: #7060A8;">deserialize</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: #7060A8;">deserialize</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: #7060A8;">deserialize</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fh</span><span style="color: #0000FF;">)</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>
+<!--

Task/Object-serialization/PicoLisp/object-serialization-1.l

@@ -0,0 +1,30 @@
+(class +Point)
+# x y
+
+(dm T (X Y)
+   (=: x (or X 0))
+   (=: y (or Y 0)) )
+
+(dm print> ()
+   (prinl "Point " (: x) "," (: y)) )
+
+(class +Circle +Point)
+# r
+
+(dm T (X Y R)
+   (super X Y)
+   (=: r (or R 0)) )
+
+(dm print> ()
+   (prinl "Circle " (: x) "," (: y) "," (: r)) )
+
+(setq
+   P (new '(+Point) 3 4)
+   C (new '(+Circle) 10 10 5) )
+
+(print> P)
+(print> C)
+
+(out "objects.dat"
+   (pr (val P) (getl P))
+   (pr (val C) (getl C)) )

Task/Object-serialization/PicoLisp/object-serialization-2.l

@@ -0,0 +1,6 @@
+(in "objects.dat"
+   (putl (setq A (box (rd))) (rd))
+   (putl (setq B (box (rd))) (rd)) )
+
+(print> A)
+(print> B)

Task/Object-serialization/Python/object-serialization.py

@@ -0,0 +1,37 @@
+# Object Serialization in Python
+# serialization in python is accomplished via the Pickle module.
+# Alternatively, one can use the cPickle module if speed is the key,
+# everything else in this example remains the same.
+
+import pickle
+
+class Entity:
+	def __init__(self):
+		self.name = "Entity"
+	def printName(self):
+		print self.name
+
+class Person(Entity): #OldMan inherits from Entity
+	def __init__(self): #override constructor
+		self.name = "Cletus"
+
+instance1 = Person()
+instance1.printName()
+
+instance2 = Entity()
+instance2.printName()
+
+target = file("objects.dat", "w") # open file
+
+#  Serialize
+pickle.dump((instance1, instance2), target) # serialize `instance1` and `instance2`to `target`
+target.close() # flush file stream
+print "Serialized..."
+
+# Unserialize
+target = file("objects.dat") # load again
+i1, i2 = pickle.load(target)
+print "Unserialized..."
+
+i1.printName()
+i2.printName()

Task/Object-serialization/Racket/object-serialization-1.rkt

@@ -0,0 +1 @@
+(require racket/serialize)

Task/Object-serialization/Racket/object-serialization-2.rkt

@@ -0,0 +1,72 @@
+#lang racket
+;; Object Serialization: Tim Brown, Oct. 2014
+(require racket/serialize)
+
+(define (join-person-name-list persons)
+  (string-join (map (λ (c) (send c ->string)) persons) ", "))
+
+(define-serializable-class person% object%
+  (init-field name [siblings null])
+  (define/public (->string #:show (show null))
+    (cond
+      [(and (member 'siblings show) (not (null? siblings)))
+       (format "~a (~a)" name (join-person-name-list siblings))]
+      [else name]))
+  (super-new))
+
+(define-serializable-class parent% person%
+  (init-field [children null])
+  (define/override (->string #:show (show null))
+    (cond
+      [(and (member 'children show) (not (null? children)))
+       (format "~a [~a]" (super ->string #:show show) (join-person-name-list children))]
+      [else (super ->string #:show show)]))
+  (super-new))
+
+;; horribly out of fashion and probaly no longer PC
+(define-serializable-class nuclear-family% object%
+  (init-field father mother children)
+  (define/public (->string)
+    (string-append
+     (format "~a + ~a -> " (send father ->string) (send mother ->string))
+     (format "~a" (join-person-name-list children))))
+  (super-new))
+
+;; =| TESTS |=========================================================================================
+(define jack (new person% [name "Jack"]))
+(define joan (new person% [name "Joan"]))
+(set-field! siblings jack (list joan))
+(set-field! siblings joan (list jack))
+(define the-kids (list jack joan))
+(define john (new parent% [name "John"] [children the-kids]))
+(define jane (new parent% [name "Jane"] [children the-kids]))
+
+(define the-family
+  (new nuclear-family% [father john] [mother jane] [children the-kids]))
+
+(define (duplicate-object-through-file o f-name)
+  (with-output-to-file f-name #:exists 'replace (λ () (write (serialize o))))
+  (with-input-from-file f-name (λ () (deserialize (read)))))
+
+(define cloned-family (duplicate-object-through-file the-family "objects.dat"))
+
+(printf "The original family:\t~a~%" (send the-family ->string))
+(printf "The cloned family:\t~a~%~%" (send cloned-family ->string))
+(printf "objects.dat contains ----~%~a~%-------------------~%~%" (file->string "objects.dat"))
+(printf "Clones are different?~%")
+(define cloned-jack (first (get-field children cloned-family)))
+(set-field! name cloned-jack "JACK")
+(printf "Jack's  name is:\t~s~%" (get-field name jack))
+(printf "Clone's name is:\t~s~%~%" (get-field name cloned-jack))
+(printf "Relationships are maintained?~%")
+(define cloned-joan (second (get-field children cloned-family)))
+(printf "Joan's description with siblings:\t~s~%" (send joan ->string #:show '(siblings)))
+(printf "Clone's description with siblings:\t~s~%~%"
+        (send cloned-joan ->string #:show '(siblings)))
+(printf "After Jack's renaming the cloned family is: ~a~%~%" (send cloned-family ->string))
+(printf "Various descriptions of cloned John:~%")
+(define cloned-john (get-field father cloned-family))
+(printf "Just the name:\t~s~%" (send cloned-john ->string))
+(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)))
+(printf "With both:\t~s~%" (send cloned-john ->string #:show '(siblings children)))

Task/Object-serialization/Raku/object-serialization.raku

@@ -0,0 +1,34 @@
+# Reference:
+# https://docs.raku.org/language/classtut
+# https://github.com/teodozjan/perl-store
+
+use v6;
+use PerlStore::FileStore;
+
+class Point {
+    has Int $.x;
+    has Int $.y;
+}
+
+class Rectangle does  FileStore {
+    has Point $.lower;
+    has Point $.upper;
+
+    method area() returns Int {
+        ($!upper.x - $!lower.x) * ( $!upper.y - $!lower.y);
+    }
+}
+
+my $r1 = Rectangle.new(lower => Point.new(x => 0, y => 0),
+                      upper => Point.new(x => 10, y => 10));
+say "Create Rectangle1 with area ",$r1.area();
+say "Serialize Rectangle1 to object.dat";
+$r1.to_file('./objects.dat');
+say "";
+say "take a peek on object.dat ..";
+say slurp "./objects.dat";
+say "";
+say "Deserialize to Rectangle2";
+my $r2 = from_file('objects.dat');
+say "Rectangle2 is of type ", $r2.WHAT;
+say "Rectangle2 area is ", $r2.area();

Task/Object-serialization/Ruby/object-serialization.rb

@@ -0,0 +1,70 @@
+class Being
+  def initialize(specialty=nil)
+    @specialty=specialty
+  end
+  def to_s
+    "(object_id = #{object_id})\n"+"(#{self.class}):".ljust(12)+to_s4Being+(@specialty ? "\n"+" "*12+@specialty : "")
+  end
+  def to_s4Being
+    "I am a collection of cooperative molecules with a talent for self-preservation."
+  end
+end
+
+class Earthling < Being
+  def to_s4Being
+    "I originate from a blue planet.\n"+" "*12+to_s4Earthling
+  end
+end
+
+class Mammal < Earthling
+  def initialize(type)
+    @type=type
+  end
+  def to_s4Earthling
+    "I am champion in taking care of my offspring and eating everything I can find, except mammals of type #{@type}."
+  end
+end
+
+class Fish < Earthling
+  def initialize(iq)
+    @iq=(iq>1 ? :instrustableValue : iq)
+  end
+  def to_s4Earthling
+    "Although I think I can think, I can't resist biting in hooks."
+  end
+end
+
+class Moonling < Being
+  def to_s4Being
+    "My name is Janneke Maan, and apparently some Earthlings will pay me a visit."
+  end
+end
+
+diverseCollection=[]
+diverseCollection << (marsian=Being.new("I come from Mars and like playing hide and seek."))
+diverseCollection << (me=Mammal.new(:human))
+diverseCollection << (nemo=Fish.new(0.99))
+diverseCollection << (jannakeMaan=Moonling.new)
+
+puts "BEGIN ORIGINAL DIVERSE COLLECTION"
+diverseCollection.each do |being|
+  puts "",being.to_s
+end
+puts "END ORIGINAL DIVERSE COLLECTION"
+puts "\n"+"*"*50+"\n\n"
+
+#Marshal the diverse Array of beings
+File.open('diverseCollection.bin','w') do |fo|
+  fo << Marshal.dump(diverseCollection)
+end
+
+#load the Array of diverse beings
+sameDiverseCollection=Marshal.load(File.read('diverseCollection.bin'))
+
+puts "BEGIN LOADED DIVERSE COLLECTION"
+puts(
+     sameDiverseCollection.collect do |being|
+       being.to_s
+     end.join("\n\n")
+     )
+puts "END LOADED DIVERSE COLLECTION"

Task/Object-serialization/Rust/object-serialization-1.rust

@@ -0,0 +1,2 @@
+serde = { version = "1.0.89", features = ["derive"] }
+bincode = "1.1.2"

Task/Object-serialization/Rust/object-serialization-2.rust

@@ -0,0 +1,48 @@
+use std::fmt;
+
+use bincode::{deserialize, serialize};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+enum Animal {
+    Dog { name: String, color: String },
+    Bird { name: String, wingspan: u8 },
+}
+
+impl fmt::Display for Animal {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Animal::Dog { name, color } => write!(f, "{} is a dog with {} fur", name, color),
+            Animal::Bird { name, wingspan } => {
+                write!(f, "{} is a bird with a wingspan of {}", name, wingspan)
+            }
+        }
+    }
+}
+
+fn main() -> bincode::Result<()> {
+    let animals = vec![
+        Animal::Dog {
+            name: "Rover".into(),
+            color: "brown".into(),
+        },
+        Animal::Bird {
+            name: "Tweety".into(),
+            wingspan: 3,
+        },
+    ];
+
+    for animal in &animals {
+        println!("{}", animal);
+    }
+
+    let serialized = serialize(&animals)?;
+
+    println!("Serialized into {} bytes", serialized.len());
+
+    let deserialized: Vec<Animal> = deserialize(&serialized)?;
+
+    println!("{:#?}", deserialized);
+
+    Ok(())
+}

Task/Object-serialization/Rust/object-serialization-3.rust

@@ -0,0 +1,3 @@
+serde = { version = "1.0.89", features = ["derive"] }
+bincode = "1.1.2"
+typetag = "0.1.1"

Task/Object-serialization/Rust/object-serialization-4.rust

@@ -0,0 +1,86 @@
+use std::fmt::{self, Debug, Display};
+
+use bincode::{deserialize, serialize};
+use serde::{Deserialize, Serialize};
+
+#[typetag::serde(tag = "animal")]
+trait Animal: Display + Debug {
+    fn name(&self) -> Option<&str>;
+    fn feet(&self) -> u32;
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Dog {
+    name: String,
+    color: String,
+}
+
+impl Display for Dog {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} is a dog with {} fur", self.name, self.color)
+    }
+}
+
+#[typetag::serde]
+impl Animal for Dog {
+    fn name(&self) -> Option<&str> {
+        Some(&self.name)
+    }
+
+    fn feet(&self) -> u32 {
+        4
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Bird {
+    name: String,
+    wingspan: u32,
+}
+
+impl Display for Bird {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} is a bird with a wingspan of {}",
+            self.name, self.wingspan
+        )
+    }
+}
+
+#[typetag::serde]
+impl Animal for Bird {
+    fn name(&self) -> Option<&str> {
+        Some(&self.name)
+    }
+
+    fn feet(&self) -> u32 {
+        2
+    }
+}
+
+fn main() -> bincode::Result<()> {
+    let animals: Vec<Box<dyn Animal>> = vec![
+        Box::new(Dog {
+            name: "Rover".into(),
+            color: "brown".into(),
+        }),
+        Box::new(Bird {
+            name: "Tweety".into(),
+            wingspan: 3,
+        }),
+    ];
+
+    for animal in &animals {
+        println!("{}", animal);
+    }
+
+    let serialized = serialize(&animals)?;
+    println!("Serialized into {} bytes", serialized.len());
+
+    let deserialized: Vec<Box<dyn Animal>> = deserialize(&serialized)?;
+
+    println!("{:#?}", deserialized);
+
+    Ok(())
+}

Task/Object-serialization/TXR/object-serialization-1.txr

@@ -0,0 +1,22 @@
+(defstruct shape ()
+  (pos-x 0.0) (pos-y 0.0))
+
+(defstruct circle (shape)
+  radius)
+
+(defstruct ellipse (shape)
+  min-radius maj-radius)
+
+(defvarl shapes (list (new circle radius 3.0)
+                      (new ellipse min-radius 4.0 maj-radius 5.0)))
+
+(put-line "original shapes:")
+(prinl shapes)
+
+(file-put "shapes.tl" shapes)
+
+(put-line "dump of shapes.tl file:")
+(put-line (file-get-string "shapes.tl"))
+
+(put-line "object list read from file:")
+(prinl (file-get "shapes.tl"))

Task/Object-serialization/TXR/object-serialization-2.txr

@@ -0,0 +1,13 @@
+(defstruct shape ()
+  (pos-x 0.0) (pos-y 0.0))
+
+(defstruct circle (shape)
+  radius
+  (:method print (me stream pretty-p)
+    (if pretty-p
+      (put-string `#<circle of radius @{me.radius} at coordinates (@{me.pos-x}, @{me.pos-y})>`)
+      :)))
+
+(let ((circ (new circle radius 5.3)))
+  (prinl circ)    ;; print machine readably
+  (pprinl circ))  ;; print pretty

Task/Object-serialization/Tcl/object-serialization.tcl

@@ -0,0 +1,52 @@
+package require Tcl 8.6
+package require TclOO::serializer 0.1
+
+# These classes are inspired by the Perl example
+oo::class create Greeting {
+    superclass oo::serializable
+    variable v
+    constructor {} {
+        set v "Hello world!"
+    }
+    method get {} {
+        return $v
+    }
+}
+oo::class create SubGreeting {
+    superclass Greeting oo::serializable
+    variable v
+    constructor {} {
+        set v "Hello world from Junior!"
+    }
+}
+oo::class create GreetingsHolder {
+    superclass oo::serializable
+    variable o1 o2
+    constructor {greeting1 greeting2} {
+        set o1 $greeting1
+        set o2 $greeting2
+    }
+    method printGreetings {} {
+        puts [$o1 get]
+        puts [$o2 get]
+    }
+    destructor {
+        $o1 destroy
+        $o2 destroy
+    }
+}
+
+# Make some objects and store them
+GreetingsHolder create holder [Greeting new] [SubGreeting new]
+set f [open "objects.dat" w]
+puts $f [oo::serialize holder]
+close $f
+
+# Delete the objects
+holder destroy
+
+# Recreate the objects from the file and show that they work
+set f [open "objects.dat" r]
+set obj [oo::deserialize [read $f]]
+close $f
+$obj printGreetings

Task/Object-serialization/Wren/object-serialization.wren

@@ -0,0 +1,61 @@
+import "/json" for JSON
+import "io" for File, FileFlags
+
+class Entity {
+    construct new(name) {
+        _name = name
+    }
+
+    name { _name }
+
+    // JSON representation
+    toString { "{\"name\": \"%(_name)\"}" }
+
+    // mimics the JSON output
+    print() { System.print(this.toString.replace("\"", "")) }
+
+    serialize(fileName) {
+        var o = JSON.parse(this.toString)
+        File.openWithFlags(fileName, FileFlags.writeOnly) { |file|
+            file.writeBytes("%(o)\n")
+        }
+    }
+}
+
+class Person is Entity {
+    construct new(name, age) {
+        super(name)
+        _age = age
+    }
+
+    // JSON representation
+    toString { "{\"name\": \"%(name)\", \"age\": \"%(_age)\"}" }
+
+    // mimics the JSON output
+    print() { System.print(this.toString.replace("\"", "")) }
+
+    serialize(fileName) {
+        var o = JSON.parse(this.toString)
+        File.openWithFlags(fileName, FileFlags.writeOnly) { |file|
+            file.writeBytes("%(o)\n")
+        }
+    }
+}
+
+// create file for serialization
+var fileName = "objects.dat"
+var file = File.create(fileName)
+file.close()
+
+System.print("Calling print methods gives:")
+
+var e = Entity.new("John")
+e.print()
+e.serialize(fileName)
+
+var p = Person.new("Fred", 35)
+p.print()
+p.serialize(fileName)
+
+System.print("\nContents of objects.dat are:")
+System.print(File.read(fileName))

Task/Object-serialization/Zkl/object-serialization.zkl

@@ -0,0 +1,26 @@
+class [static] ARootClass{ // A top level class, no instances
+   class A{ self.println(" constructor"); } // a regular class
+   class B(A){ // ditto
+      var x;
+      fcn init(x=123){ self.x=x }
+      fcn toString{ "x is "+x }
+   }
+}
+
+ARootClass.B(456).println(); // create an instance
+   // prints:
+   Class(A) constructor
+   x is 456
+
+f:=File("object.dat","wb");
+Compiler.Asm.writeRootClass(ARootClass,f); // serialize to file
+f.close();
+
+f:=File("object.dat","rb");
+rc:=Compiler.Asm.readRootClass(f); // read and re-create
+   // prints (readRootClass calls all constructors by default):
+   Class(A) constructor
+f.close();
+rc.B().println();  // create a new instance of B
+   // prints:
+   x is 123