' Rapid-Q by William Yu (c)1999-2000                                             .
' ================================================================================
' Upload_il_tuo_script_su_Rapidq.it

' Capitolo_7__Introduzione_ai_flussi

****** 7: Introduzione ai flussi ******
Rapid-Q supporta flussi di file anzichè il comando standard OPEN utilizzato in
BASIC. Funzionano in modo analogo, ma hanno nomi diversi. I vantaggi principali dei
flussi sono le dimensioni illimitate ed il fatto di poter copiare da e verso flussi
diversi (per esempio File e Memoria).

7.1 Flussi di file
I flussi di file sono utilizzati per creare, leggere e scrivere dei file. Tutti i
flussi sono aperti in modo binario, senza possibilità di blocco (tutti i file
aperti sono condivisi). Questi sono i metodi di apertura dei file:
     fmCreate    - Crea un file, sovrascrive se il file esiste già 
     fmOpenRead  - Apre un file in sola lettura
     fmOpenWrite - Apre un file in sola scrittura
     fmOpenReadWrite - Apre un file in lettura & scrittura
Per aprire un file si deve indicare il nome del file ed uno dei metodi
sopraindicati.
     DIM File AS QFileStream

     File.Open('Test.txt', fmOpenRead)
In questo modo si apre il file Test.txt in sola lettura. Per leggere i dati, si
utilizzano i metodi ReadNum e ReadStr. Vedere RAPIDQ.INC per i codici validi.
     PRINT File.ReadNum(Num_SINGLE)   '-- Legge 4 bytes come numero di tipo SINGLE
     PRINT File.ReadStr(1024)         '-- Legge 1024 byte
E' possibile immagazzinare il valore in una variabile, utilizzando le routine
generiche Read e Write.
     File.Read(A&)          '-- Leggi un valore Long e memorizzalo in A&
     File.Write(B#)         '-- Scrivi il valore Double B#

     '-- o analogamente, con un pò più di lavoro:
     A& = File.ReadNum(Num_LONG)
     File.WriteNum(B#, Num_DOUBLE)
Una volta terminato di lavorare con il file, assicuratevi di chiudere la maniglia.
Potrete poi riutilizzare il flusso ed aprire un altro file. Per verificare se avete
raggiunto la fine del file, potete confrontare File.Position e File.Size o
verificare se File.EOF è vero (-1). Fintanto che File.Position è inferiore a
File.Size, non avete raggiunto la fine del file. Esistono due modi per verificare
se un file esiste:
     IF FileExists('Test.txt') <> FALSE THEN
       File.Open('Test.txt', fmOpenRead)
     END IF
Tuttavia, è preferibile utilizzare semplicemente:
     IF File.Open('Test.txt', fmOpenRead) = FALSE THEN
        ShowMessage('Impossibile aprire il file')
     END IF
File.Open restituirà un numero diverso da zero se il file è stato aperto
correttamente, 0 in caso contrario.

7.2 Flussi di memoria
Un flusso di memoria viene creato con il comando DIM. È simile a un flusso di file,
ed ha gli stessi metodi, come ReadNum, WriteNum, ecc... L'unica differenza è che i
flussi di memoria sono immagazzinati nella memoria, che può essere aumentata o
ridotta senza limiti. È anche possibile memorizzare matrici di numeri nei flussi di
memoria (vedere esempio ARRAYS.BAS). I flussi di memoria servono per diversi scopi,
fate lavorare la vostra immaginazione. Un utilizzo potrebbe essere la
memorizzazione di dati temporanei, ad esempio copiando un file in un flusso di
memoria e manipolando i dati in seguito. Come si esegue una copia da un flusso ad
un altro? È semplice, si può copiare fra flussi diversi (per esempio da File a
Memoria) o flussi dello stesso tipo (per esempio da Memoria a Memoria).
    DIM File AS QFileStream
    File.Open('test.txt', fmOpenRead)

    DIM Memory AS QMemoryStream
    Memory.CopyFrom(File, File.Size)  '-- Copia tutto
Come avrete notato, abbiamo copiato l'intero contenuto del nostro file 'test.txt'
nel nostro flusso di memoria. Ora potete manipolare il flusso di memoria senza
toccare il file.

7.3 Salvataggio/Caricamento di UDT e Matrici
Il salvataggio ed il caricamento di UDT è semplice come passare l'UDT ad un
QFileStream o QMemoryStream.
    TYPE TTest
        S AS STRING*8
        N AS INTEGER
    END TYPE

    DIM Test AS TTest
    DIM File AS QFileStream

    File.Open('test.txt', fmCreate)
    File.WriteUDT(Test)
    File.Close
Nell'esempio precedente, sono stati salvati 12 byte nel file test.txt. Otto byte
per la stringa S, e 4 per N. Per leggere l'UDT, utilizzare il metodo ReadUDT.
    File.Open('test.txt', fmOpenRead)
    File.ReadUDT(Test)
Il salvataggio ed il caricamento di matrici è altrettanto semplice.
    DIM A(1 TO 100) AS LONG
    DIM File AS QFileStream

    File.Open('test.txt', fmCreate)
    File.SaveArray(A(1), 100)
    File.Close
Il primo parametro di SaveArray è l'elemento iniziale della matrice da salvare, e
nell'esempio precedente può essere qualunque valore da 1 a 100. Il parametro
successivo specifica quanti elementi della matrice salvare. In questo caso abbiamo
scelto di salvare tutti gli elementi da 1 a 100. Analogamente, possiamo utilizzare
LoadArray per leggere i dati:
    File.Open('test.txt', fmOpenRead)
    File.LoadArray(A(1), 100)
Il flussi sono molto usati nella maggior parte dei linguaggi di alto livello per la
manipolazione di file e memoria, ma non è facile abituarcisi, soprattutto per
vecchi utenti Basic.



' ===============================================================================
'                      2003 Holyguard.net - 2007_Abruzzoweb