Persistencia en Zero

He actualizado el tutorial (también práctica de la asignatura Tecnología de Objetos de la ESEI), sobre persistencia cuasi-ortogonal en Zero.

El tutorial ahora incluye un nuevo ejemplo, mucho más sencillo, como introducción, y explica cómo se pueden guardar objetos con un programa y recuperarlos con otro, y, aprovechando la existencia de la excepción EObjectNotFound, fusionar ambos programas en uno, como de hecho hace la agenda telefónica, presente al final del tutorial.

La implantación de persistencia, y su uso educativo como muestra de cómo debería haberse implantado persistencia mediante sistemas operativos orientados a objetos, son la verdadera razón de ser del sistema de programación Zero. La mayor influencia sobre Zero para su sistema de persistencia proviene de Barbados. El PS (almacenamiento persistente) se divide en contenedores, que guardan los objetos como si de directorios se tratase. El objetivo es no padecer el problema de que los spaghetti pointer hagan que sacar un solo objeto del PS suponga llevarse, eventualmente, todos los objetos residentes en él.

El tutorial comienza con un primer ejemplo muy sencillo, que se reproduce a continuación.

Supóngase que se desea almacenar un objeto como el punto:

object Punto
    attribute + x = 0;
    attribute + y = 0;
   
    method + set(a, b)
    {
        x = a;
        y = b;
       
        return;
    }
   
    method + toString()
    {
        reference toret = x.toString();
       
        toret = toret.concat( ", " );
        toret = toret.concat( y.toString() );
       
        return toret;
    }
endObject

Así, para guardar un objeto en el almacenamiento persistente es necesario crear un contenedor, e introducir el objeto en él.

       object GuardaPunto: ConsoleApplication
            method + doIt()
            {
                reference p = Punto.createChild( "p" );
                reference c = ContainerInstance.copy( "PruebaPunto" );
                   
                // Rellenar el punto
                p.set( 100, 150 );
                   
                // Hacerlo persistente
                c.add( p );
                psRoot.add( c );
                   
                return;
            }
        endObject

Lo lógico sería hacer ahora un programa para recuperarlo, aunque sucede que este programa es extremadamente sencillo:

            object RecuperaPunto: ConsoleApplication
                method + doIt()
                {
                    System.console.writeLn( psRoot.PruebaPunto.p );
                   
                    return;
                }
            endObject

Resulta mucho más lógico y coherente fusionar ambos programas en uno, aprovechándose del hecho de que se lanzará una excepción si no se encuentra el objeto en el PS, pasando por tanto a crearlo.

 object RecuperaPruebaPersistenciaPunto: ConsoleApplication
    method + crea()
    {
        reference p = Punto.createChild( "p" );
        reference c = ContainerInstance.copy( "PruebaPunto" );
       
        // Rellenar el punto
        p.set( 100, 150 );
       
        // Hacerlo persistente
        c.add( p );
        psRoot.add( c );
       
        return;
    }
   
    method + recupera()
    {
        return psRoot.PruebaPunto.p;
       
        onException( e ) {
            System.console.writeLn( "Creando punto..." );
            this.crea();
            return psRoot.PruebaPunto.p;
        }
    }
   
    method + doIt()
    {
        System.console.writeLn( this.recupera() );
        return;
    }
   
endObject