Italian community of Lazarus and Free Pascal

Attenzione

L'articolo è da considerarsi obsoleto in quanto fa uso di una libreria che oramai è stata pienamente superata dal codice presente nella unit fpjson distribuita insieme al compilatore pascal.
Una documentazione molto esauriente (tratta sia XML che JSON) è stata fornita dall'autore stesso della unit ed è visionabile tramite il seguente link:
http://www.freepascal.org/~michael/articles/webdata/webdata.pdf

Segue l'articolo originale.


Articolo originale

Si sente spesso parlare di file JSON e se ne sente spesso parlare
relativamente allo sviluppo su web in quanto basato sul linguaggio
JavaScript (Standard ECMA-262 3ª edizione dicembre 1999).
In realtà la sua vera natura - quella di essere un formato per
l'interscambio di dati tra applicazioni - lo ha portato ad essere
usato nei contesti più disparati nell'ambito della programmazione e,
come si può desumere da "http://www.json.org/", oramai esistono
librerie per moltissimi linguaggi di programmazione, incluso il FreePascal.

Ha diverse mancanze rispetto all'XML. Ad esempio non ha il concetto di
attributo e non è utilizzabile né con file XLST, né con file DTD.
Ha però dalla sua la semplicità della rappresentazione delle
strutture dati (e quindi facilità nel parsing) e la semplicità di
essere letto e manipolato dagli esseri umani.

Giusto per avere un primo e semplice approccio, segue un esempio in
questo formato:


{
  "nome"     : "Paolo Rossi",
  "eta"      : 33,
  "email": ["prossi@ppp.it","paolorossi@xpop3.it"],
  "indirizzi": [
    {
      "indirizzo": "Via Dei Mille, 34",
      "citta"    : "Milano",
      "provincia": "MI"
    },
    {
      "indirizzo": "Via T. Tasso, 1",
      "citta"    : "Messina",
      "provincia": "ME"
    }
  ]
}


La semplicità salta subito all'occhio. Si tratta fondamentalmente di
combinazioni nome/valore dove il valore, quando di tipo stringa, è
delimitato dal doppio apice.
Un accenno particolare va ai campi "email" ed "indirizzi" che in
realtà sono rappresentazioni di array. Un array è delimitato dalle
parentesi quadre e quando composto da una semplice lista di valori
("email") basta indicare gli elementi separati da una virgola. Quando
invece l'array è composto da tipi strutturati ("indirizzi"), gli
elementi vanno specificati tra parentesi graffe.


Ora però, come esempio pratico, vorrei proporre l'uso di questo
formato per la memorizzazione delle impostazioni necessarie ad una
ipotetica applicazione dedicata all'aggiornamento dei database.

Segue il contenuto del file "": database.def.

{
  /*
    questo è un commento                              
  */

  /* impostazioni globali */
  "name"    : "Employee",
  "release" : "0.1",

  /* informazioni sui database da aggiornare */
  "targets": [
    {
      "type"    : "Firebird 2.0",
      "host"    : "192.168.0.1",
      "database": "/db/fb2.0/myprojects/EMPLOYEE.FDB",
      "user"    : "SYSDBA",
      "password": "masterkey",
      "settings": [
         {
           "type"     : "database",
           "page"     : "8192",
           "dialect"  : 3,
           "collation": "ISO8859_1"
         }
      ]
    },
    {
      "type"    : "Firebird 1.5",
      "host"    : "192.168.0.2",
      "database": "/db/fb1.5/myprojects/EMPLOYEE.FDB",
      "user"    : "SYSDBA",
      "password": "masterkey",
      "settings": [
         {
           "type"     : "database",
           "page"     : "8192",
           "dialect"  : 3,
           "collation": "ISO8859_1"
         }
      ]
    }
   
  ],

}


La libreria che andremo a provare l'ho stata scaricata dal sito
http://code.google.com/p/superobject/downloads/list
e per chi volesse saperne di più: http://www.progdigy.com/
Si tratta di sorgenti con doppia licenza: MPL o LGPL. Una volta
decompresso il file superobjectv1.2.4.zip, avremo a disposizione 2 file
sorgenti chiamati superobject.pas e superxmlparser.pas che si occupano
rispettivamente del parsing dei file JSON ed XML. A corredo anche una
serie di demo e di progetti test da studiare. Tra le demo, ci sono
interessanti applicazioni con google search, RTTI e VirtualTreeView.

Tornando al nostro ipotetico tool per l'aggiornamento di database,
andiamo a creare, con Lazarus, una nuova applicazione. Tramite
l'analizzatore progetti possiamo aggiungere la unit superobject.pas al
nostro progetto (il tutto risiede in un unico file .PAS e non
ci sono pacchetti da installare).
Sulla form principale aggiungiamo:
- un TEdit chiamato edDefPath ed impostiamo la proprietà Text con la
fullpath del file database.def
- un TButton
- un TMemo chiamato Memo1

Torniamo al sorgente della form principale e, sotto implementation,
mettiamo in "uses" superobject. Fatto questo, nella sezione public,
dichiariamo:
    procedure ScanDef(FilePath: string; log: TStrings);

segue il relativo codice:

procedure TForm1.ScanDef(FilePath: string; log: TStrings);
var
  obj, item: ISuperObject;
  tottargets, scanitem: integer;
  tottsettings, scansettings: integer;
begin

   try

     log.Add('reading structure...');
     log.Add('   path: ' + FilePath);
     obj := TSuperObject.ParseFile(FilePath, TRUE);
     log.Add('   read success');

     log.Add('   type       : ' + obj['type'].AsString );
     log.Add('   name       : ' + obj['name'].AsString );
     log.Add('   release    : ' + obj['release'].AsString );

     // targets
     tottargets := obj['targets'].AsArray.Length;
     log.Add('   nr. targets: ' + IntToStr(tottargets) );
     for scanitem:=0 to tottargets - 1 do begin
        item := obj['targets'].AsArray.O[scanitem];
        log.Add( '   * target: ' + inttostr(scanitem + 1) );
        log.Add( '      type        : ' + item['type'].AsString );
        log.Add( '      host        : ' + item['host'].AsString );
        log.Add( '      path        : ' + item['path'].AsString );
        log.Add( '      user        : ' + item['user'].AsString );
        log.Add( '      password    : ' + item['password'].AsString );

        tottsettings := item['settings'].AsArray.Length;
        log.Add('      nr. settings: ' + IntToStr(tottsettings) );
        for scansettings:=0 to tottsettings - 1 do begin
           item := item['settings'].AsArray.O[scansettings];
           log.Add( '      * settings: ' + inttostr(scansettings + 1) );
           log.Add( '         type     : ' + item['type'].AsString );
           log.Add( '         page     : ' + item['page'].AsString );
           log.Add( '         dialect  : ' + item['dialect'].AsString );
           log.Add( '         collation: ' + item['collation'].AsString );
        end;

     end;

   except
      on e: exception do begin
         log.Add('');
         log.Add('');
         log.Add('*** ERRORE ***');
         log.Add(e.Message);
      end;
   end;

end;


Ultima cosa da ricordare, impostare il richiamo della procedura

nell'evento double click di Button1:


procedure TForm1.Button1Click(Sender: TObject);
begin
   ScanDef(edDefPath.Text, Memo1.Lines);
end;


a questo punto non resta che lanciare il tutto con F9 e cliccare su
Button1. Se tutto è andato come doveva, vedrete popolare il Memo con
le impostazioni lette dal file.

Quello mostrato qui è solo un piccolo sottoinsieme delle possibilità
che si hanno a disposizione con l'utilizzo di questa libreria; una
volta iniziato a capire come funziona è possibile dare un'occhiata
alle varie demo e al file README.html per scoprirne altre funzionalità.

Buon Lavoro.
nomorelogic