File- típus-konstrukciók Szlávi Péter ELTE Informatika Szakmódszertani Csoport

 Programozásmódszertan 2 Tartalomjegyzék 0 BevezetésBevezetés 1 A file-típuskonstrukciók specifikálásaA file-típuskonstrukciók specifikálása 1.1 InputSzekvenciálisFileInputSzekvenciálisFile 1.2 OutputSzekvenciálisFileOutputSzekvenciálisFile 1.3 DirektFileDirektFile 1.4 AsszociatívFileAsszociatívFile 2 A file-típuskonstrukciók moduljaA file-típuskonstrukciók modulja 2.1 InputSzekvenciálisFileInputSzekvenciálisFile 2.2 OutputSzekvenciálisFileOutputSzekvenciálisFile 2.3 DirektFileDirektFile 2.4 AsszociatívFileAsszociatívFile 2.5 IndexSzekvenciálisFileIndexSzekvenciálisFile

 Programozásmódszertan 3 Tartalomjegyzék (folytatás) 3 „Alap” file-modulok„Alap” file-modulok 3.1 Tartalomjegyzék-FileTartalomjegyzék-File 3.2 Fizikai FileFizikai File 3.3 File-PufferFile-Puffer

 Programozásmódszertan 4 0 Bevezetés File-ok „madártávlatból” „operációs lényeg”, háttértár  memória valós adatok  absztrakt adatobjektum Operációs rendszer-szintű alapfogalmak: Blokk, gap, puffer, sáv (cylinder), blokkmutató File, -azonosító, -attribútumok, -header File-ok a lemezen, tartalomjegyzék, blokk-lánc, lemeztérkép (FAT) Asszociatív tárolás, kulcs, -indexelés

 Programozásmódszertan 5 0 Bevezetés (folytatás) Programozási nyelv (Pascal) file-fogalmai: File-deklarációk, definíciók File of TElem, Text, file-változó=puffer File-megnyitási szertartások Assign, ReSet/ReWrite, {$i-}, IOResult Assign(f,fNev); {$i-} ReSet(f); {$i+} hiba:=IOResult<>0; If hiba then Halt(9);Halt Nyitás olvasásra Assign(f,fNev); {$i-} ReSet(f); hiba:=IOResult<>0; If hiba then ReWrite(f) else Halt(9); {$i+} Nyitás írásra

 Programozásmódszertan 6 0 Bevezetés (folytatás) További file-műveletek: I:Procedure Read(Var f:TFile; Var x:TElem); Function Eof(Var f:Tfile):Boolean; O :Procedure Write(Var f:TFile; Const x:TElem); I/O :Procedure Close(Var f:TFile); TFile=Text esetén a Read, Write műveletek- ben a TElem többféle lehet, de csak olyan, amihez van beépített TElem  String -konverziós függvény.

 Programozásmódszertan 7 0 Bevezetés (folytatás) I:Procedure Readln(Var f:Text; Var x:TElem); O:Procedure Writeln(Var f:Text; Const x:TElem); Típusos file-ok: TFile  Text (azaz TElem  Char ) Input/Output Procedure Seek(Var f:TFile; Const poz:LongInt); „Emlékezetnélküliség”Emlékezetnélküliség Text-beli sorfogalom

 Programozásmódszertan 8 1 File-specifikációk InputSzekvenciálisFile (ISzF): Nyit, Zár, Olvas, Vége? OutputSzekvenciálisFile (OSzF): Nyit, Zár, Ír DirektFile (DF): Nyit/Létrehoz, Zár, Olvas, Ír, Méret, Töröl, Bővít AsszociatívFile (AF): Nyit/Létrehoz, Zár, Olvas, Ír, Hossz, Méret, Töröl, Méretez

 Programozásmódszertan 9 1 File-specifikációk (folytatás) Jelölések: LétFile: Létező (azaz az adathordozón már létrehozott) file-ok halmaza; NemLétFile: a még nem kész file-ok halmaza; LétFile  NemLétFile=  File: az összes file-ok halmaza File=LétFile  NemLétFile f:LétFile  f=()  f=(f 0,…) NemDef: típusfüggetlen konstans

 Programozásmódszertan 10 1 File-specifikációk (folytatás) f i :TElem  {NemDef} NTermészetes számok = N NNe:TElem, k:TKulcs, TIndex= N [{0,1,…}], i,db: N A nyitó és záró műveletek legfőbb célja a file „át- vitele” az egyik file-halmazból egy másikba. Fontos megjegyzés: A műveletek szignatúrája nagyon fontos informá- cióforrás: mire alkalmazható és mire képez le. Következmény: olyan helyzeteket általában nem axiomatizálunk, amelyek „képtelensége” kiolvas- hatók pusztán a szignatúrából.

 Programozásmódszertan 11 1 File-specifikációk 1.1 InputSzekvenciálisFile Típus ISzF(TElem): Asszociált műveletek: Nyit(File): ISzF  {NemDef} Zár(ISzF): File \ ISzF Olvas(ISzF): ISzF  TElem  {NemDef} Vége?(ISzF): Logikai Nyit Zár LétFile  ISzF  LétFile Olvas Vége?

 Programozásmódszertan InputSzekvenciálisFile (folytatás) Axiomák: 1 ° Nyitni csak már korábban létrehozott és nem nyitott file-t lehet. f  LétFile  f  ISzF   Nyit(f) f  LétFile  f  ISzF  Nyit(f)=NemDef 2 ° Nyitás után az első elem lesz az aktuális (amire a legközelebbi olvasás művelettel hivatkozhatunk), vagy a végénél tartunk. g=Nyit(f)  (  Vége?(g)  Olvas(g)=(g’,g 0 ))  (Vége?(g)  g=() )  Nyit(f)  Nyit(f)  NemDef

 Programozásmódszertan InputSzekvenciálisFile (folytatás) 3 ° A vége után nem lehet olvasni. Vége?(f)  Olvas(f)=NemDef 4 ° Olvasás után az aktuális a következő elem lesz, vagy a végére értünk. (Olvas(f)=(g,f i )  g=(f 0,…,f i,f i+1,...)  f i  NemDef   Vége?(g)  Olvas(g)=(g’,f i+1 ) (Olvas(f)=(g,f i )  g=(f 0,...,f i )  Vége?(g) )

 Programozásmódszertan 14 1 File-specifikációk 1.2 OutputSzekvenciálisFile Típus OSzF(TElem): Asszociált műveletek: Nyit(File): OSzF  {NemDef} Zár(OSzF): File \ OSzF Ír(OSzF,TElem): OSzF Nyit Zár NemLétFile  OSzF  LétFile Ír

 Programozásmódszertan OutputSzekvenciálisFile (folytatás) Axiómák: 1 ° Nyitni csak nem létező file-t lehet. f  LétFile   Nyit(f) f  LétFile  Nyit(f)=NemDef 2 ° A file csak a zárással válik (az adathordozón) létezővé. f  OSzF  f  LétFile  Zár(f)  LétFile 3 ° Nyitás után az első elem lesz az aktuális (amire a következő írás művelet vonatkozhat). g=Nyit(f)  Ír(g,e)=g’  g’=(e)

 Programozásmódszertan OutputSzekvenciálisFile (folytatás) 4 ° Írás egy elemmel bővíti a file-t, az utolsó mögé kerül az új elem. f  OSzF  f=(f 0,…,f n )  Ír(f,e)=(f 0,…,f n,e)

 Programozásmódszertan 17 1 File-specifikációk 1.3 DirektFile Újdonságok: Közvetlen és indexben nem korlátozott elemelérés (Tömb „változó” mérettel) Bővíthetőség, csonkíthatóság NTIndex= N Többféle megközelítés létezik. (L. még Típspec.pdf!)Típspec.pdf Típus DF(TElem): Asszociált műveletek: N Nyit(File): DF  {NemDef} Létrehoz(File, N ): DF  {NemDef}

 Programozásmódszertan DirektFile (folytatás) N N N N N Zár(DF): File \ DF Olvas(DF, N ): TElem  {NemDef} Ír(DF, N,TElem): DF  {NemDef} Méret(DF): N Bővít(DF, N ): DF Töröl(DF, N ): DF Nyit,Létrehoz Zár File  DF  LétFile Ír,Olvas,Méret,Bővít,Töröl

 Programozásmódszertan DirektFile (folytatás) Axiómák: 1 ° Nyitás után a file mérete éppen az „elemek számá- val” egyenlő. f  LétFile  Nyit(f)=g  g=(g 0,g 1,..,g n,..)  g n  NemDef   i>n: g i =NemDef  Méret(g)=n+1 f  LétFile  Nyit(f)=NemDef Megjegyzés: a törlés és bővítés miatt g i =NemDef is lehetséges.

 Programozásmódszertan DirektFile (folytatás) 2 ° Még nem létező file létrehozása után a file mérete éppen a felvett elemek számával egyenlő. f  LétFile  g=Létrehoz(f,db)  Méret(g)=db   i  [0,db) : g i =NemDef f  LétFile  Létrehoz(f,db)=NemDef Kérdés: Igaz-e, hogy g=Zár(Létrehoz(f,db))  Méret(Nyit(g))=db 3 ° (Nyitás után) bármely eleme elérhető, és értéke az, amit utoljára kapott, esetleg nem definiált (ha még nem kapott). i  [0,Méret(f)): Olvas(Ír(f,i,e),i)=e  (f i =NemDef  Olvas(f,i)=NemDef)

 Programozásmódszertan DirektFile (folytatás) 4 ° Az írás csak azt az elemet változtatja meg, amelyiket írja. Méreten túli írás nem definiált. i,j  [0,Méret(f)): i  j  Olvas(Ír(f,i,e),j)=Olvas(f,j) i  Méret(f)  Ír(f,i,e)=NemDef 5 ° Törléskor a méret a paraméterrel meghatározott számmal csökken; a végéről éppen ennyi elemet hagy el –ha van annyi–. h  [0,Méret(f)]   g=Töröl(f,h)  Méret(g)=Méret(f)–h  i  [0,Méret(g)): g i =f i h  Méret(f)  Töröl(f,h)=Töröl(f,Méret(f))

 Programozásmódszertan DirektFile (folytatás) 6 ° Bővítéskor a többlet-méretparaméternek megfelelően nő, az új elemek nem definiált értékűek. g=Bővít(f,h)  Méret(g)=Méret(f)+h  i  [0,Méret(f)): g i =f i  i  [Méret(f),Méret(g)): g i =NemDef 7 ° Minden művelet hatása a háttértáron rögvest „érzé- kelhető”, nem csak a zárás után. f  DF  f  LétFile

 Programozásmódszertan 23 1 File-specifikációk 1.4 AsszociatívFile Újdonságok: Indexelés kulcs segítségével, egy Méret mé- retű Táblázatban, valamely Hash-függvénnyel TKulcs –generálható: Kulcs(TElem):TKulcs; Kulcs(NemDef)=NemDef –rendezhető: <(TKulcs,TKulcs):Logikai Elérés szekvenciálisan (is) <-sorrendben  Indexelt(szekvenciális)File(IxF)  AsszociatívFile

 Programozásmódszertan AsszociatívFile (folytatás) N Algebrai leíráshoz egy „elemfelsoroló” függvény  (TElem): N az alábbi tulajdonságokkal: 1. f=(f 0,…,f n )  i  [0,n]:  (f i )  [0,n] 2. f=(…,f i,…,f j,...)  Kulcs(f i )<Kulcs(f j )   (f i )<  (f j ) Típus AF(Kulcs(TElem):TKulcs, TElem): Asszociált műveletek: N Nyit(File): AF  {NemDef} Létrehoz(File, N ): AF  {NemDef} Zár(AF): File \ AF

 Programozásmódszertan AsszociatívFile (folytatás) N N Olvas(AF,TKulcs): TElem  {NemDef} Ír(AF, TElem): AF  {NemDef} Hossz(AF): N [a definiált elemek száma] Méret(AF): N Méretez(AF, Z ): AF  {NemDef} Töröl(AF,TKulcs): AF Indexel(DF,Kulcs(TElem):TKulcs): AF Nyit,Létrehoz Zár File  AF  LétFile Ír,Olvas,Hossz,Méret,Méretez,Töröl

 Programozásmódszertan AsszociatívFile (folytatás) Axiómák: 1 ° A Nyit létező file esetén használható művelet, a hossz egyenlő a (definiált értékű) elemek számával. f  LétFile  Nyit(f)=g  g=(g 0,g 1,..,g n )  Hossz(g)=n+1   i  [0,n]: g i  NemDef  Méret(g)  n+1 f  LétFile  Nyit(f)=NemDef Megjegyzés: az f=(f 0,f 1,...)  AF mint sorozatban az indexek- nek semmi köze sincs a fizikai sorrendhez! l. DirektFile-nál. DirektFile

 Programozásmódszertan AsszociatívFile (folytatás) 2 ° Ha a nyitandó file nem létezik, akkor a Létrehoz 0 db elemmel hozza létre, db mérettel, db nem definiált elemmel. f  LétFile  g=Létrehoz(f,db)  Méret(g)=db  Hossz(g)=0   i  [0,db): g i =NemDef f  LétFile  Létrehoz(f)=NemDef 3 ° (Nyitás után) bármely elem elérhető, és értéke az, amit utoljára kapott, esetleg nem definiált (ha még nem kapott). Olvas(Ír(f,e),Kulcs(e))=e  f i : Kulcs(f i )  k  Olvas(f,k)=NemDef l. DirektFile-nál. DirektFile

 Programozásmódszertan AsszociatívFile (folytatás) 4a ° Nem létez ő kulcsú elem írásakor a hossz eggyel nő, feltéve, hogy nem telt be a file. Hossz(f)=n  n<Méret(f)  f=(f 0,f 1,...,f n-1 )   i  [0,n): Kulcs(f i )  Kulcs(e)  Hossz(Ír(f,e))=Hossz(f)+1 Hossz(f)=Méret(f)  Ír(f,e)=NemDef 4b ° Megengedett a létező kulcsú elem módosítása. Kulcs(e)=k  e  Olvas(f,k)  Olvas(Ír(f,e),k)=e 4c ° Adott kulcsú elem módosítása más elemet nem változtathat meg. Kulcs(e)  k  Olvas(Ír(f,e),k)=Olvas(f,k)

 Programozásmódszertan AsszociatívFile (folytatás) 5 ° Törléskor az adott elem nem definiált értékűvé válik, s a hossz eggyel csökken, méret nem változik. Kulcs(f i )=k  Töröl(f,k)=g  Olvas(g,k)=NemDef  Hossz(g)=Hossz(f)-1  Méret(f)=Méret(g) Kulcs(e)  k  Töröl(f,k)=NemDef 6a ° Méretezéskor a hossz nem változik (pozitív paraméter esetén megfelelő számú nem definiált értékű elem ke- letkezik).  g=Méretez(f,h)  Méret(g)=Méret(f)+h  Hossz(g)=Hossz(f)  i  [0,Hossz(f)): g i =f i h>0  i  (Hossz(f),Hossz(f)+h]: g i =NemDef

 Programozásmódszertan AsszociatívFile (folytatás) 6b ° Méretezés során elem nem veszhet el, azaz hossznál kisebb méretűre nem méretezhető. Méret(f)+h<Hossz(f)  Méretez(f,h)=NemDef 7 ° Minden művelet hatása a háttértáron rögvest „érzékel- hető”, nem csak a zárás után. f  AF  f  LétFile

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Típus IxF(Kulcs(TElem):TKulcs, <(TKulcs,TKulcs):Logikai, TElem): Asszociált műveletek: AFAF + Olvas(IxF): IxF  TElem  {NemDef} Olvas(IxF,TKulcs): IxF  TElem  {NemDef} Vége?(IxF): Logikai Nyit,Létrehoz Zár File  IxF  LétFile Ír,Olvas,Olvas,Hossz,Méret,Méretez,Töröl,Vége? A szekvenciális olvasás miatt „emlékeznie” kell, hogy hol tart.

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Axiómák: AFAF + 3b ° Nyitás után szekvenciális olvasással a rendezés szerinti első elem érhető el. g=Nyit(f)  Hossz(g)>0  Olvas(g)=(g’,e)   (e)=0   Vége?(g) g=Nyit(f)  Hossz(g)=0  Olvas(g)=NemDef  Vége?(g) 

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) 3c ° Sikeres szekvenciális olvasás, „kulcsos” olvasás, ill. írás, vagy törlés után a –rendezés szerinti– kö- vetkező elemet lehet szekvenciális olvasással elér- ni, vagy ha ilyen nincs (azaz vége a file-nak), akkor nem definiált az olvasás eredménye.  (g,e)=Olvas(f)   Vége?(g)  (  (g’,g i )=Olvas(g)   (g i )=  (e)+1)  (g,e)=Olvas(f)  Vége?(g)  Olvas(g)=NemDef ehhez hasonlóan a többi műveletre …  (g,e)=Olvas(f,k) ... Vége?(g)   g i :  (e)  (g i )

 Programozásmódszertan 34 2 A file-típuskonstrukciók moduljai Import: –DirFile: legalapvetőbb adminisztratív modul –FizFile: háttértár (láncolt „blokk-tömb/lista”)  puffer (folytonos TElem-tömb) –FilePuffer: puffer (TElem-sor, -tömb)  TElem (DirFile  ) FizFile  Függvény FileSiker: Logikai (globális hibaváltozó) (DirFile  ) FizFile  FileLeíróRekord (FLR)

 Programozásmódszertan 35 2 A file-típuskonstrukciók moduljai Mudulhierarchia DirFile modul DirFile modul FizFile modul FilePuffer modul ISzF modul OSzF modul DF modul AF modul IxF modul

 Programozásmódszertan 36 2 A file-típuskonstrukciók moduljai 2. 1 InputSzekvenciálisFile ExportModul ISzF(Típus TElem): Eljárás Nyit(Változó f:ISzF, Konstans fnév:Szöveg) Eljárás Zár(Változó f:ISzF) Eljárás Olvas(Változó f:ISzF, r:TElem) Függvény Vége?(Konstans f:ISzF): Logikai Függvény FileSiker:Logikai Modul vége. Meg kell gondolni az operátorok ef/uf-ét az axiómák alapján!

 Programozásmódszertan InputSzekvenciálisFile (folytatás) Modul ISzF(Típus TElem): Import FilePuffer  Eljárás Pufferból,PufferInic Függvény PufferÜres? FizFile  Típus FLR Konstans Input [  NyitásiMód típus ] Változó Siker Eljárás FizNyit,FizZár, ElsőBlokkOlvas,KövBlokkOlvas Függvény UtolsóBlokk?,FileSiker Sor-szerűen tekintve Láncolt listának tekintve

 Programozásmódszertan InputSzekvenciálisFile (folytatás) Reprezentáció Változó f:FLR'MutatóFLR Implementáció [Megállapodás: az FLR egyes mezőire történő hi- vatkozás pusztán a mezőnév vel történik a pontos FLR(f).mezőnév helyett.] Eljárás Nyit(Változó f:ISzF, Konstans fnév:Szöveg): FizNyit(f,fnév,Input,Méret’TElem) Ha Siker akkor Ha hossz>0 akkor ElsőBlokkOlvas(f) különben PufferInic(f) Elágazások vége Eljárás vége.FizNyit

 Programozásmódszertan InputSzekvenciálisFile (folytatás) Eljárás Zár(Változó f:ISzF): FizZár(f,Input) Eljárás vége.FizZár Eljárás Olvas(Változó f:ISzF, r:TElem): Ha PufferÜres?(f) akkor Siker:=Hamis különben Pufferból(f,r) Ha PufferÜres?(f) és nem UtolsóBlokk?(f) akkor KövBlokkOlvas(f) Elágazások vége Eljárás vége.

 Programozásmódszertan InputSzekvenciálisFile (folytatás) Függvény Vége?(Konstans f:ISzF): Logikai Vége?:=PufferÜres?(f) és UtolsóBlokk?(f) Függvény vége. Inicializálás … Modul Vége.

 Programozásmódszertan 41 2 A file-típuskonstrukciók moduljai 2.2 OutputSzekvenciálisFile ExportModul OSzF(Típus TElem): Eljárás Nyit(Változó f:OSzF, Konstans fnév:Szöveg) Eljárás Zár(Változó f:OSzF) Eljárás Ír(Változó f:OSzF, Konstans r:TElem) Függvény FileSiker:Logikai Modul vége.

 Programozásmódszertan OutputSzekvenciálisFile (folytatás) Modul OSzF(Típus TElem): Import FilePuffer  EljárásPufferba,PufferInic FüggvényPufferTele?,PufferÜres? FizFile  TípusFLR EljárásFizNyit,FizZár, KövBlokkÍr VáltozóSiker KonstansOutput [  NyitásiMód típus ] Függvény FileSiker

 Programozásmódszertan OutputSzekvenciálisFile (folytatás) Reprezentáció Változó f:FLR'MutatóFLR Implementáció Eljárás Nyit(Változó f:OSzF, Konstans fnév:Szöveg): FizNyit(f,fnév,Output,Méret’TElem) Ha Siker akkor PufferInic(f) Eljárás vége.FizNyit Eljárás Zár(Változó f:OSzF): Ha PufferTele?(f) akkor KövBlokkÍr(f) PufferInic(f) Pufferba(f,fileVég); KövBlokkÍr(f) FizZár(f,Output) Eljárás vége.FizZár

 Programozásmódszertan OutputSzekvenciálisFile (folytatás) Eljárás Ír(Változó f:OSzF, Konstans r:TElem): Pufferba(f,r) Ha PufferTele?(f) akkor KövBlokkÍr(f); PufferInic(f) Eljárás vége. Inicializálás … Modul Vége.

 Programozásmódszertan 45 2 A file-típuskonstrukciók moduljai 2.3 DirektFile ExportModul DF(Típus TElem): TípusRekSorsz Eljárás Nyit(Változó f:DF, Konstans fnév:Szöveg) Eljárás Létrehoz(Változó f:DF, Konstans fnév:Szöveg, db:NNEgész) Eljárás Zár(Változó f:DF) Eljárás Olvas(Változó f:DF, Konstans i:RekSorsz, Változó r:TElem)

 Programozásmódszertan DirektFile (folytatás) Eljárás Ír(Változó f:DF, Konstans i:RekSorsz, r:TElem) Eljárás Töröl(Változó f:DF, Konstans i:NNEgész) Eljárás Bővít(Változó f:DF, Konstans i:NNEgész) Függvény Méret(Konstans f:DF): RekSorsz Függvény FileSiker:Logikai Modul vége.

 Programozásmódszertan DirektFile (folytatás) Modul DF(Típus TElem): Import FilePuffer  EljárásPufferba,Pufferból, PufferInic FizFile  Típus FLR,BlokkSorsz,RekSorsz EljárásFizNyit,FizZár, BlokkÍr,BlokkOlvas VáltozóSiker KonstansOutput,Módosít Függvény FileSiker DirFile  Eljárás Fixál Ezek tömb-szerű műveletek!

 Programozásmódszertan DirektFile (folytatás) Reprezentáció Változó f:FLR'MutatóFLR Implementáció Eljárás Nyit(Változó f:DF, Konstans fnév:Szöveg): FizNyit(f,fnév,Módosít,Méret’TElem) Ha Siker akkor BlokkOlvas(f,1) változás:=Hamis Elágazás vége Eljárás vége.

 Programozásmódszertan DirektFile (folytatás) Eljárás Létrehoz(Változó f:DF, Konstans fnév:Szöveg, db:NNEgész): Változó bs:BlokkSorsz FizNyit(f,fnév,Output,Méret’TElem) Ha Siker akkor bs:=(db+pufferElemszám-1) div pufferElemszám Lefoglal(f,bs) Ha Siker akkor...

 Programozásmódszertan DirektFile (folytatás) … Ha Siker akkor PufferInic(f); hossz:=db aktB:=1; változás:=Hamis Fixál(f) [ tartalomjegyzékben ] Elágazás vége Elágazás vége Eljárás vége. Eljárás Zár(Változó f:DF): Ha változás akkor BlokkÍr(f,aktB) FizZár(f,Output) Eljárás vége.

 Programozásmódszertan DirektFile (folytatás) Eljárás Ír(Változó f:DF Konstans e:TElem, i:NNEgész): Ha i>hossz akkor Siker:=Hamis különben bs:=(i div pufferElemszám)+1 Ha változás és bs  aktB akkor BlokkÍr(f,aktB) aktB:=bs; BlokkOlvas(f,aktB) Elágazás vége db:=i mod pufferElemszám változás:=Igaz; Pufferba(f,db,r) Elágazás vége Eljárás vége.

 Programozásmódszertan DirektFile (folytatás) … Olvas, Méret, Bővít, Lefoglal, Felszabadít … Inicializálás … Modul vége. FLR-pontosítás

 Programozásmódszertan 53 2 A file-típuskonstrukciók moduljai 2.4 AsszociatívFile ExportModul AF ( Típus TElem, Függvény Kulcs(TElem):TKulcs ) : TípusRekSorsz Eljárás Nyit(Változó f:AF, Konstans fnév:Szöveg) Eljárás Létrehoz(Változó f:AF, Konstans fnév:Szöveg, db:NNEgész) Eljárás Zár(Változó f:AF)

 Programozásmódszertan AsszociatívFile (folytatás) Eljárás Olvas(Változó f:AF, Konstans k:TKulcs, Változó r:TElem) Eljárás Ír(Változó f:AF, Konstans r:TElem) Eljárás Töröl(Változó f:AF, Konstans k:TKulcs) Eljárás Bővít(Változó f:AF, Konstans db:NNEgész)

 Programozásmódszertan AsszociatívFile (folytatás) Függvény Hossz(Konstans f:AF): RekSorsz Függvény Méret(Konstans f:AF): RekSorsz Függvény FileSiker:Logikai Modul vége.

 Programozásmódszertan AsszociatívFile (folytatás) Modul AF(Típus TElem, Függvény Kulcs(TElem):TKulcs): Import DF  Változó Siker Eljárás Nyit,Zár,Olvas,Ír Függvény Hossz,FileSiker Típus RekSorsz Reprezentáció TípusElemJell=(Szabad,Foglalt, Törölt) TAElem=Rekord( attr:ElemJell, ért:TElem) Változóf:DF(TAElem) Lin. szétszórt altáblás módszer

 Programozásmódszertan AsszociatívFile (folytatás) Eljárás Nyit(Változó f:AF, Konstans fnév:Szöveg): Nyit(f,fnév) Eljárás vége. Eljárás Létrehoz(Változó f:AF, Konstans fnév:Szöveg, db:NNEgész): Változó i:NNEgész Létrehoz(f,fnév,db) Ha Siker akkor Ciklus i=0-tól db-1-ig Ír(f,i,TAElem(Szabad,?)) Ciklus vége Elágazás vége Eljárás vége.

 Programozásmódszertan AsszociatívFile (folytatás) Eljárás Zár(Változó f:AF): [ újraszervez: a töröltek kihagyása… ] Zár(f) Eljárás vége. Eljárás Olvas(Változó f:AF, Konstans k:TKulcs,Változó r:TElem): Változó rSz:RekSorsz ar:TAElem Keres(f,k,rSz) [ valamit mindig találjon! ] OlvasOlvas(f,rSz,ar)[ l. deklarációját ] Ha ar.attr=Foglalt és k=Kulcs(ar.ért) akkor r:=ar.ért különbenSiker:=Hamis l. deklarációját Eljárás vége. Itt van, vagy itt kéne lennie

 Programozásmódszertan AsszociatívFile (folytatás) Eljárás Ír(Változó f:AF, Konstans r:TElem): Változó rSz:RekSorsz ar:TAElem Keres(f,Kulcs(r),rSz) Olvas(f,rSz,ar) Ha ar.attr=Szabad vagy k=Kulcs(ar.ért) akkor Ír(f,rSz,TAElem(Foglalt,r)) különbenSiker:=HamisÍr Eljárás vége. Itt van, vagy ide illik

 Programozásmódszertan AsszociatívFile (folytatás) Eljárás Töröl(Változó f:AF, Konstans k:TKulcs): Változó rSz:RekSorsz ar:TAElem Keres(f,k,rSz); Olvas(f,rSz,ar) Ha ar.attr=Foglalt és k=Kulcs(ar.ért) akkor Ír(f,rSz,TAElem(Törölt,?) különben Siker:=Hamis Eljárás vége.

 Programozásmódszertan AsszociatívFile (folytatás) Függvény Keres(Változó f:AF, Konstans k:Tkulcs, Változó rs:RekSorsz):Logikai … [ kulcstranszformáció, kulcsütközés lekezelése: rs-hez illik, Igaz; teli: Hamis; adott kulcsúig keresés (mégha törölt is) vagy szabadig; nem feltétlenül a legközelebbi helyen áll meg, de ez nem baj! ] Függvény vége. … [… Eljárás Méretez … ] Inicializálás … Modul vége.

 Programozásmódszertan 62 2 A file-típuskonstrukciók moduljai 2.5 IndexSzekvenciálisFile ExportModul IxF ( Típus TElem, Függvény Kulcs(TElem):TKulcs, Operátor <(TKulcs,TKulcs):Logikai ) : TípusRekSorsz Eljárás Nyit(Változó f:IxF, Konstans fnév:Szöveg) Eljárás Létrehoz(Változó f:IxF, Konstans fnév:Szöveg, db:NNEgész) Eljárás Zár(Változó f:IxF)

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Olvas(Változó f:IxF, Konstans k:TKulcs, Változó r:TElem) Eljárás Olvas(Változó f:IxF, r:TElem) Eljárás Ír(Változó f:AF, Konstans r:TElem) Eljárás Töröl(Változó f:IxF, Konstans k:TKulcs) Eljárás Méretez(Változó f:IxF, Konstans db:NNEgész) Függvény Vége?(Konstans f:IxF):Logikai

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Függvény Hossz(Konstans f:IxF): RekSorsz Függvény Méret(Konstans f:IxF): RekSorsz Függvény FileSiker:Logikai Modul vége.

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Modul IxF ( Típus TElem, Függvény Kulcs(TElem):TKulcs, Operátor <(TKulcs,TKulcs):Logikai ) : Import DF  Változó Siker Eljárás Nyit,Zár,Olvas,Ír Függvény Hossz,FileSiker Típus RekSorsz

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Reprezentáció Típus TInd=Rekord(kulcs:TKulcs, rsorsz:RekSorsz) Változó fő:DF(TElem) if:DF(TInd) [ folyamatosan kulcs-rendezett állapotban; hogy logaritmikusan lehes- sen keresni benne ] akt:NNEgész [ aktuális elem if -beli indexe ] …

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Nyit(Változó f:IxF, Konstans fnév:Szöveg): Nyit(fő,fnév); Nyit(if,’ix_’+fnév) akt:=-1 [ a szekvenciális Olvas miatt ]Olvas Eljárás vége. Eljárás Zár(Változó f:IxF): [ a fő file törölt elemeinek (amire nem hivatkozik if - beli elem) kihagyása ] Zár(fő); Zár(if) Eljárás vége. Az index-file „szab- ványos” prefixe: ‘ ix_ ’. L. 3b°3b°

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Olvas(Változó f:IxF, Konstans k:TKulcs, Változó r:TElem): Változó iRSz:RekSorsz indRek:TInd Ha LogKeres(if,k,iRSz) akkor akt:=iRSz Olvas(if,iRSz,indRek) Olvas(fő,indRek.rsorsz,r) különben Siker:=Hamis Elágazás vége Eljárás vége.

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Olvas(Változó f:IxF, Változó r:TElem): Változó indRek:TInd Ha akt  Hossz(if) akkor akt:+1 Olvas(if,akt,indRek) Olvas(fő,indRek.rsorsz,r) különben Siker:=Hamis Elágazás vége Eljárás vége.

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Ír(Változó f:IxF, Konstans r:TElem): … [ a fő file végére írás, bővítés után; helykeresés if -ben, helycsinálás, beillesztés a megfe- lelő TInd elemnek; akt -állítás ] Eljárás vége.

 Programozásmódszertan IndexSzekvenciálisFile (folytatás) Eljárás Töröl(Változó f:IxF, Konstans k:TKulcs): Változó iRSz:RekSorsz indRek:TInd Ha LogKeres(if,k,iRSz) akkor akt:=iRSz-1 [ a szekvenciális Olvas miatt ] … [ az if iRSz mögötti elemeinek előretolása ] Töröl(if,1) különben Siker:=Hamis Elágazás vége Eljárás vége.Olvas … Modul vége. L. 3c°3c°

 Programozásmódszertan 72 3 „Alap” file-modulok Szintek: Tartalomjegyzék File (DirFile) file-bejegyzések file-ja alapadatok „főexportőrje” (FLR, Siker…) Fizikai File (FizFile) lemezblokkok kezelője File-puffer I/O-puffer kezelője

 Programozásmódszertan 73 3 „Alap” file-modulok 3.1 Tartalomjegyzék-File - DirFile ExportModul DirFile: Konstans PufHossz:NNEgész(?) Típus BlokkMutató=? RekSorsz=NNEgész BlokkSorsz=NNEgész TPuffer=Tömb(1..PufHossz: Byte) [ Tömb/Sor; csak a méret számít; a használatánál „sérül” majd a szi- gorú típusosság; Tömb(1..PuffHossz:Byte)  Tömb(1..?:TElem)] Egy vagy két szám… File-relatív sorszám.

 Programozásmódszertan DirFile (folytatás) A fő fogalom: Típus FLR=Rekord (fnév:Szöveg elsőbl,aktbl:BlokkMutató aktB:BlokkSorsz hossz, elemHossz,pufferHossz, pufferElemSzám:NNEgész puffer:TPuffer pufferAkt:NNEgész fileVég:? változás:Logikai)

 Programozásmódszertan DirFile (folytatás) Konstans Sehova:BlokkMutató(?) Eljárás Beolvas [ a tartalomjegyzék beolvasása ] Eljárás Ellenőriz [ jó lemez van-e benn, stb. ? ] Eljárás Fixál [ a tartalomjegyzék kiírása ] Függvény KövBlokkMut (Konstans mut:BlokkMutató): BlokkMutató Függvény FileSiker:Logikai Függvény BlokkotKér( Változó mut:BlokkMutató): BlokkMutató [mut -hoz kapcsolja a kapott blokkot ]

 Programozásmódszertan DirFile (folytatás) Eljárás Keres(Változó f:FLR’Mutató, Konstans fn:Szöveg) [fn nevű file-t keres; f mezőit beállítja ] Függvény FileSiker:Logikai Változó Siker:Logikai [ minden szinten állított flag ] Modul vége.

 Programozásmódszertan DirFile (folytatás) Modul DirFile: Reprezentáció KonstansMaxFLeir:NNEgész(?) TípusTAttri= ? TIdő= ? Bejegyzés=Rekord (fnév:Szöveg idő:TIdő attri:TAttri első:BlokkMutató hossz:NNEgész …)

 Programozásmódszertan DirFile (folytatás) BlokkPuffer= Tömb(1..MaxFLeir: Bejegyzés) BlokkInfo=Rekord (köv:BlokkMutató milyen:(Rossz,… Foglalt,Szabad) FileTérkép= Tömb(BlokkMutató: BlokkInfo)

 Programozásmódszertan DirFile (folytatás) KonstansElsőDirBlokk: BlokkMutató(?) Változódir:BlokkPuffer map:FileTérkép Siker:Logikai akt:BlokkMutató [ saját ]

 Programozásmódszertan DirFile (folytatás) Implementáció Eljárás Beolvas: akt:=ElsőDirBlokk DirOlvas(akt); MapOlvas Siker:=Igaz[ ha sikerült ] Eljárás vége. Eljárás Fixál: DirÍr(akt); MapÍr Siker:=Igaz[ ha sikerült ] Eljárás vége. … Modul vége.

 Programozásmódszertan 81 3 „Alap” file-modulok 3.2 Fizikai File - FizFile ExportModul FizFile: TípusFLR BlokkSorsz,RekSorsz NyitásiMód=(Input,Output, Módosít) Eljárás FizNyit(Változó f:FLR'Mut., Konstans fnév:Szöveg, mód:NyitásiMód, eh:NNEgész) Eljárás FizZár(Változó f:FLR'Mut., Konstans mód:NyitásiMód)

 Programozásmódszertan FizFile (folytatás) Eljárás ElsőBlokkOlvas(Változó f: FLR'Mutató) Eljárás KövBlokkOlvas(Változó f: FLR'Mutató) Eljárás KövBlokkÍr(Változó f: FLR'Mutató) Eljárás BlokkOlvas(Változó f: FLR'Mutató, Konstans bs:BlokkSorsz) Eljárás BlokkÍr(Változó f: FLR'Mutató, Konstans bs:BlokkSorsz)

 Programozásmódszertan FizFile (folytatás) Függvény UtolsóBlokk?(Változó f: FLR'Mutató):Logikai Függvény FileSiker:Logikai Modul vége.

 Programozásmódszertan FizFile (folytatás) Modul FizFile: Import DirFile  Konstans PufHossz Eljárás Beolvas,Fixál,Ellenőriz, Keres Függvény KövBlokkMut,FileSiker Változó Siker FilePuffer  Eljárás PufferInic Reprezentáció [ maga a háttértár a DirFile-on keresztül ]

 Programozásmódszertan FizFile (folytatás) Implementáció Eljárás FizNyit( Változó f:FLR'Mutató, Konstans fnév:Szöveg, mód:NyitásiMód, eh:NNEgész): Változó bm:BlokkMutató Ellenőriz; LefoglalFLRt(f) Ha Siker akkor Keres(f,fnév)[ f-t kitölti,Siker-t állítja ] változás:=Hamis [ pontosabban: FLR(f).változás később is így rövidítünk! ]

 Programozásmódszertan FizFile (folytatás) Elágazás Siker és mód  Output esetén [sikeres megnyitás] Siker és mód=Output esetén Siker:=Hamis ElengedFLRt(f) Nem Siker és mód  Output esetén Siker:=Hamis ElengedFLRt(f)

 Programozásmódszertan FizFile (folytatás) Nem Siker és mód=Output esetén elemHossz:=eh hossz:=0 pufferHossz:=PufHossz fileVég:= ? bm:=BlokkKér(Sehova) [ az első blokkot nincs mihez láncolni ]

 Programozásmódszertan FizFile (folytatás) Ha Siker akkor aktbl:=bm elsőbl:=bm különben ElengedFLRt(f) Elágazás vége Elágazás vége Elágazás vége Eljárás vége.

 Programozásmódszertan FizFile (folytatás) Eljárás FizZár(Változó f:FLR'Mut., Konstans mód:NyitásiMód): Ha mód=Output akkor Fixál(f) Elágazás vége ElengedFLRt(f) Eljárás vége.

 Programozásmódszertan FizFile (folytatás) Eljárás LefoglalFLRt(Változó f:FLR'Mut.) … Eljárás ElengedFLRt(Változó f:FLR'Mut.) … Modul vége.

 Programozásmódszertan 91 3 „Alap” file-modulok 3.3 FilePuffer ExportModul FilePuffer: Eljárás PufferInic,Pufferból, Pufferba Függvény PufferTele?,PufferÜres? Modul vége.

 Programozásmódszertan FilePuffer (folytatás) Modul FilePuffer: Import DirFile  Konstans PufHossz Típus FLR,TPuffer Változó Siker Reprezentáció [ importálva a TPuffer -t ] Implementáció Eljárás PufferInic( Változó f:FLR'Mutató): pufferAkt:=1 pufferHossz:=PufHossz Eljárás vége.

 Programozásmódszertan FilePuffer (folytatás) Eljárás Pufferból( Változó f:FLR'Mutató,e:TElem): … [ sor-szerű „kivevő” művelet ] Eljárás vége. Eljárás Pufferból( Változó f:FLR'Mutató, Konstans i:NNEgész, Változóe:TElem): … [ tömb-szerű „kivevő” művelet ] Eljárás vége. … Modul vége. polimorfizmus polimorfizmus

 Programozásmódszertan 94 Megjegyzés: FLR Típus FLR=Rekord (fnév:Szöveg, puffer:TPuffer, hossz:NNEgész, aktB:NNEgész, változás:Logikai elemHossz:NNEgész pufferHossz:NNEgész pufferElemszám:NNEgész...) ISzF,OSzF,DF

 Programozásmódszertan 95 Megjegyzés: Halt... A példában szereplő Halt a programozási gyakorlatban kerülendő. Most egyszerűsítési okok miatt használjuk. Alkalmazás csak akkor megengedett, ha a programnak nincs módja új adatkéréssel helyesbítést kezdeményezni (pl. hibás adat input file-ban). Tanács: ha vannak fatális hibamegállások, akkor is egyetlen eljárásba sűrítsük ezeket.

 Programozásmódszertan 96 Megjegyzés: „Emlékezetnélüliség”... Type Napok=(Hetfo,...); Var f:File of Napok; g:File of Byte;... Assign(f,’titok.dat’); ReWrite(f); For i:=Hetfo to Vasarnap do Write(f,i); Close(f);... Assign(g,’titok.dat’); ReSet(g); While Not Eof(g) do Begin Read(g,ig); Writeln(Napok(ig),’:’,ig); End; Close(g);... DDDD eeee mmmm oooo

 Programozásmódszertan 97 Megjegyzés: Polimorfizmus Polimorfizmus = műveletek többalakúsága. Azonosítása egyértelműen megoldható, ha paraméterei számában és/vagy típusában eltérnek. Klasszikus példa a polimorf operátorokra: –értékadás –relációk...