ARCHIV

Perl (72) - Navazování složitějších datových typů

Pokračujeme v tématu předchozího dílu. Budeme se zabývat méně obvyklými záležitostmi při navazování proměnných.

3.9.2008 06:00 | Jiří Václavík | Články autora | přečteno 13386×

Podobně jako skaláry můžeme navazovat složitější datové typy. Nejčastěji se používá navazování hashů, které je používáno zejména systémem DBM. Více bude o DBM řečeno v příštím díle. Nicméně dnes se budeme zabývat i navazováním ovladačů souborů.

Na začátku uveďme, že stejně jako pro skaláry je možné pro přetížení jen vybraných operací použít třídy Tie::StdArray a Tie::StdHash definované v modulech Tie::Array a Tie::Hash.

S hashi a poli lze provádět mnohem zajímavější věci než se skaláry. Představme si, že bychom přes hash přistupovali například k encyklopedii. Takový hash bychom vůbec nemuseli definovat - stačilo by ho pouze svázat s modulem, který by se staral o získávání informací. Ten by mohl data získávat třeba i z Wikipedie. Okamžítě bychom tak měli dostupná hesla pod příslušnými klíči.

Navazování hashů

Navazování hashů je to o něco složitější než navazování skalárů, nicméně tato složitost tkví zejména v počtu metod, které musíme vytvořit. Je to logické, protože si stačí uvědomit, co všechno lze s hashem provádět.

Konstruktorem třídy bude metoda TIEHASH. Dále zde opět máme metody FETCH a STORE. Jako argumenty dostávají klíč hashe pro FETCH, resp. klíč a hodnotu pro STORE.

Narozdíl od skaláru zde však máme navíc další metody. V hashovém kontextu můžeme využívat funkce exists a delete. Jejich chování určují metody EXISTS a DELETE. Obě dostávají jako argument klíč hashe.

Dále zde máme metodu CLEAR, která je volána tehdy, pokud do hashe přiřazujeme prázdný seznam. Pokud přiřazujeme neprázdný seznam, není třeba definovat zvláštní metodu, neboť takové volání se převede na volání CLEAR a STORE.

A nakonec je třeba definovat metody FIRSTKEY a NEXTKEY, které obsluhují volání funkce keys (funkce values a each jsou pouze kombinací FIRSTKEY, NEXTKEY a FETCH). Metoda FIRSTKEY by měla vracet název prvního klíče a NEXTKEY postupně klíče následující. Pokud tedy nad navázaným hashem zavoláme funkci keys, provede se metoda FIRSTKEY. Pokud zavoláme keys znovu, provede se NEXTKEY. Atd.

Příklad

Nyní si pro jasnější představu napíšeme konkrétní třídu, ke které budeme moci hash navázat. Obsah nenavázaných proměnných se uchovává v paměti RAM. Naše třída bude proměnné navázané na ní uchovávat v adresáři. Budeme tedy pracovat s hashem a veškeré operace s ním se budou odehrávat na úrovni práce se soubory.

Tedy konkrétně. Vytvořením prvku hashe se vytvoří v daném adresáři soubor o stejném názvu jako je klíč hashe. Obsahem souboru pak bude hodnota prvku. Prvky budeme moci přepisovat, mazat apod.

Přikročme tedy k definici třídy. Konstruktor TIEHASH bude přijímat název adresáře, z něhož vytvoří objekt. Dále tento adresář vytvoří. Pro jednoduchost nebudeme ošetřovat případy, kdy by bylo třeba vytvořit více podadresářů.

package TieHash;

sub TIEHASH {
    my($pkg, $adresar) = @_;
    $adresar = "hash" unless $adresar;
    mkdir $adresar unless -e $adresar;
    bless \$adresar, $pkg;
    return \$adresar;
}

A nyní již budeme definovat metody reprezentující operace s hashem. STORE na základě přijatých argumentů vytvoří v daném adresáři soubor s daným obsahem.

sub STORE {
    my($r_dir, $soubor, $obsah) = @_;
    open FILE, ">$$r_dir/$soubor" or die;
    print FILE $obsah;
    close FILE;
}

Metoda FETCH přečte soubor, reprezentující daný index a vrátí jeho obsah.

sub FETCH {
    my($r_dir, $soubor) = @_;
    return "" unless -e "$$r_dir/$soubor";
    open FILE, "$$r_dir/$soubor" or die;
    my $obsah = <FILE>;
    close FILE;
    return $obsah;
}

Metoda EXISTS pouze vrátí pravdivou nebo nepravdivou hodnotu, podle toho, zda daný soubor existuje.

sub EXISTS {
    my($r_dir, $soubor) = @_;
    return -e "$$r_dir/$soubor" ? 1 : "";
}

Volání funkce delete má za následek smazání daného prvku. Zároveň zajistíme, aby byla vrácena hodnota tohoto prvku.

sub DELETE {
    my($r_dir, $soubor) = @_;
    return "" unless -e "$$r_dir/$soubor";
    my $obsah = $r_dir->FETCH($soubor);
    unlink "$$r_dir/$soubor";
    return $obsah;
}

Přiřazením prázdného seznamu do hashe se všechny klíče hashe vymažou.

sub CLEAR {
    my($r_dir) = @_;
    unlink <$$r_dir/*>;
}

A nakonec nám zbývají metody FIRSTKEY a NEXTKEY. Zde vyvstává otázka, jak uchovávat informaci mezi jednotlivými voláními metody. Potřebujeme totiž vědět, které klíče již byly vráceny a které zatím ne. Nejčastější možností je uchovávání celého hashe v objektu. Potom bychom mohli pomocí funkce each volat pokaždé následující prvek. Nicméně my v objektu máme pouze jméno adresáře. Pro jednoduchost definujeme globální proměnnou $posledni, která říká kolikátý byl poslední vrácený klíč.

Nyní definujeme metodu FIRSTKEY, která vrací první název souboru z daného adresáře.

sub FIRSTKEY {
    my($r_dir) = @_;
    my($s) = <$$r_dir/*>;
    my($a) = $s =~ /$$r_dir\/(.*)/;
    $posledni = 0;
    return $a;
}

A nakonec metodu NEXTKEY, která nejprve do pole načte všechna jména souborů a poté z nich vybere podle obsahu globální funkce $posledni.

sub NEXTKEY {
    my($r_dir) = @_;
    my @files;
    push @files, /$$r_dir\/(.*)/ while <$$r_dir/*>;
    return $files[++$posledni] ? $files[$posledni] : undef;
}

Třída je hotova. Nyní ji můžeme začít navazovat na konkrétní hashe.

my %a;
tie %a, "TieHash";

Dále můžeme zkoušet pracovat s prvky hashe %a a zároveň sledovat obsah vzniklého adresáře hash. Například následující příkaz má za následek vytvoření souboru hash/klic s obsahem hodnota.

Další příkaz smaže obsah adresáře a poté v něm vytvoří soubor novy s obsahem hodnota.

A nakonec si vypíšeme obsahy všech souborů adresáře hash.

Navazování polí

Konstruktorem je opět metoda TIEARRAY. Dále máme k dispozici nám již známé FETCH a STORE. A dále lze ještě využít metody DELETE, EXISTS, CLEAR, POP, PUSH, SHIFT, UNSHIFT a SPLICE, jejichž význam je intuitivní. Metoda FETCHSIZE se volá po požadavku na délku pole (to může být buď $#pole nebo scalar $pole). STORESIZE naopak definuje chování pro změnu jeho velikosti.

Příklad

V příkladu, který si uvedeme, budeme definovat pouze některé z výše uvedených metod, neboť rozsáhlejší příklad jsme si již předvedli u navazování hashů.

Do prvku pole budeme přiřazovat vždy název souboru. Naše třída zajistí, že hodnotou prvku bude obsah tohoto souboru a ne už jeho název.

package TieArray;
use Tie::Array;
our @ISA = ("Tie::StdArray");

sub TIEARRAY {
    my($pkg, $adresar) = @_;
    my $self = [];
    bless $self, $pkg;
    return $self;
}

sub STORE {
    my($self, $index, $soubor) = @_;
    return "" unless -r $soubor;
    open FILE, "$soubor";
    $self->[$index] .= $_ while <FILE>;
    close FILE;
}

sub PUSH {
    my($self, @nove_hodnoty) = @_;;
    my $i = -1;
    $self->STORE($#$self+1, $nove_hodnoty[$i]) while $nove_hodnoty[$i++];
}

Nyní můžeme naši třídu použít. Po přiřazení do proměnné se její hodnotou ve skutečnosti stane obsah souboru nebo prázdný řetězec.

my @a;
tie @a, "TieArray";

$a[0] = "/home/user/soubor";
print $a[0];

Navazování ovladačů

Odpovědnost za práci s ovladači můžeme jako u předcházejících datových typů přenést z Perlu na sebe. Opět to spočívá ve vytvoření speciální třídy, uvnitř které jsou definovány speciální metody.

Protože ovladač nemá vlastní prefix, předává se funkci tie typeglob.

Máme také k dispozici modul Tie::Handle, ve kterém je definována třída Tie::StdHandle.

Konstruktorem třídy, na kterou budou ovladače navázány, je metoda TIEHANDLE. Dále máme určeny pro jednotlivé operace s ovladačem další názvy metod.

Metody PRINT, PRINTF, GETC, OPEN, CLOSE, BINMODE, FILENO, SEEK, TELL, EOF korespondují s funkcemi o stejném názvu, pouze malým písmem, WRITE s funkcí syswrite a READ s funkcemi read a sysread.

Dále zde máme funkci READLINE, která je volána při čtení z ovladače pomocí operátoru <>.

Verze pro tisk