Save object to file in Logtalk

Question

I've written a prolog project and now I have to change it to Logtalk file. In the code I can assert new facts to another prolog file with the code:

:- dynamic(student/5).
:- use_module(library(persistency)).

:- persistent(student(id, name, surname, mark, studies)).
:- initialization(db_attach('student_database.pl', [])).

add_student(ID, Name, Surname, Mark, Studies):-
    with_mutex(student_db, assert_student(ID, Name, Surname, Mark, Studies)).

Now I want to make something similar in Logtalk, but not with facts, but objects. Ofc I know how to make new object (by create_object/4 with protocol), but I don't know how to save it in a file as database.

The protocol looks like:

:- protocol(student).

    :- public([
        id/1,
        name/1,
        surname/1,
        studies/1,
        marks/1
    ]).

:- end_protocol.

Can anyone help me with saving these objects?

Answer 1

Serializing dynamic objects can be complex in general depending on the objects dependencies but your case seems simpler as each object only depends on a single protocol and only contains facts.

When using a backend Prolog system that supports saved states (e.g. SICStus Prolog, SWI-Prolog, or YAP), a simple solution is to create a saved state. As there is no standard for saved states, this solution is necessarily non-portable.

When saved states are not possible or a portable solution is sought, we need to define a format to the saved data so that we can interpret it when loaded and restore the objects. Let's assume that we want to restore the objects as dynamic objects (as they were originally created using the create_object/4 predicate) and use a simple representation, data/1, for the saved state. We can define a generic serializer object as follows (not tested):

:- object(serializer).

    :- public([
        save/2,
        restore/1
    ]).

    save(Protocol, File) :-
        protocol_property(Protocol, public(Predicates)),
        open(File, write, Stream),
        write_canonical(Stream, protocol(Protocol)), write(Stream, '.\n'),
        forall(
            conforms_to_protocol(Object, Protocol),
            save_object(Object, Predicates, Stream)
        ),
        close(Stream).

    save_object(Object, Predicates, Stream) :-
        object_data(Predicates, Object, [], Data),
        write_canonical(Stream, data(Data)), write(Stream, '.\n').

    object_data([], _, Data, Data).
    object_data([Functor/Arity| Predicates], Object, Data0, Data) :-
        functor(Fact, Functor, Arity),
        findall(Fact, Object::Fact, Data1, Data0),
        object_data(Predicates, Object, Data1, Data).

    restore(File) :-
        open(File, read, Stream),
        read_term(Stream, Term, []),
        restore_object(Term, _, Stream),
        close(Stream).

    restore_object(end_of_file, _, _).
    restore_object(protocol(Protocol), Protocol, Stream) :-
        read_term(Stream, Term, []),
        restore_object(Term, Protocol, Stream).
    restore_object(data(Data), Protocol, Stream) :-
        create_object(_, [implements(Protocol)], [], Data),
        read_term(Stream, Term, []),
        restore_object(Term, Protocol, Stream).

:- end_object.

This is just a starting point, however. It can be improved in several ways but that mainly require more details about the particular serialization scenario.

Update

Added a serialization example to the Logtalk git version based on the code above: https://github.com/LogtalkDotOrg/logtalk3/tree/master/examples/serialization