Quiq::Perl - Erweiterte und abgesicherte Perl-Operationen
Quiq::Object
Die Klasse implementiert grundlegende Perl-Operationen, die Erweiterungen darstellen und/oder durch Exception-Behandlung abgesichert sind.
$this->autoFlush($fh); $this->autoFlush($fh,$bool);
Schalte Pufferung auf Dateihandle ein oder aus.
Der Aufruf ist äquivalent zu
$oldFh = select $fh; $| = $bool; select $oldFh;
perldoc -f select
Quiq::Perl->autoFlush(*STDOUT);
$class->binmode($fh); $class->binmode($fh,$layer);
Schalte Filehandle $fh in Binärmodus oder setze Layer $layer. Die Methode ist eine Überdeckung der Perl-Funktion binmode und prüft deren Returnwert. Im Fehlerfall wirft die Methode eine Exception.
perldoc -f binmode
Quiq::Perl->binmode(*STDOUT,':encoding(utf-8)');
Quiq::Perl->print($fh,@data);
Schreibe Daten @data auf Dateihandle $fh. Die Methode ist eine Überdeckung der Perl-Funktion print und prüft deren Returnwert. Im Fehlerfall wirft die Methode eine Exception.
perldoc -f print
Quiq::Perl->print($fh,"Hello world\n");
$class->use($class,$sloppy);
Lade Klasse $class per use. Im Fehlerfall wirft die Methdoe eine Exception. Ist $sloppy wahr, wird keine Exception geworfen, sondern ein boolscher Wert: 1 für erfolgreiche Ausführung, 0 für fehlgeschlagen. Die globale Variable $@ gibt den Grund an.
loadClass()
@arr|$val = Quiq::Perl->perlDoFile($file);
Überdeckung für die Perl-Funktion do() in der Variante do($file). Die Funktion liefert den Wert des letzten ausgewerteten Ausdrucks bei Ausführung der Datei $file. Im Fehlerfall wirft die Funktion eine Exception.
Genaue Funktionsbeschreibung siehe Perl-Dokumentation.
Laden einer Konfigurationsdatei:
%cfg = Quiq::Perl->perlDoFile($file);
Inhalt Konfigurationsdatei:
use strict; host => 'localhost', datenbank => 'entw1', benutzer => ['sys','system']
$type = $this->sigilToType($sigil);
Wandele $sigil ('$', '@' oder '%') in Datentyp-Bezeichner ('SCALAR', 'ARRAY' oder 'HASH') und liefere diesen zurück.
$refH = $this->stash($package);
Liefere eine Referenz auf den "Symbol Table Hash" (Stash) des Package $package. Der Hash enthält für jede globale Variable und jedes Unterpackage einen Eintrag. Existiert der Stash nicht (und damit auch nicht das Package), liefere undef.
@arr|$arr = $this->packages; @arr|$arr = $this->packages($package);
Liefere die Liste der existierenden Packages, die im Stash des Package $package und darunter enthalten sind, einschließlich Package $package selbst. Im Skalarkontext liefere eine Referenz auf die Liste. Wird die Methode ohne Argument aufgerufen wird Package 'main' angenommen.
Anmerkung
Packages entstehen zur Laufzeit. Die Liste der Packages wird nicht gecacht, sondern mit jedem Aufruf neu ermittelt.
Liste aller Packages, die das Programm aktuell geladen hat:
@arr = Quiq::Perl->packages;
Liste in sortierter Form
@arr = Quiq::Perl->packages->sort;
Liste, eingeschränkt auf Packages, deren Name einen Regex erfüllt:
@arr = Quiq::Perl->packages->select(qr/patch\d+/);
Liste aller Packages unterhalb und einschließlich Package X:
@arr = Quiq::Perl->packages('X');
$class->createClass($newClass,@baseClasses);
Erzeuge Klasse $newClass, falls sie noch nicht existiert, und definiere die Klassen @baseClasses als deren Basisklassen. Die Methode liefert keinen Wert zurück.
Die Basisklassen werden per "use base" geladen.
$bool = $class->classExists($class);
packageExists()
Prüfe, ob die Perl-Klasse bzw. das Package $class in-memory existiert, also von Perl bereits geladen wurde. Liefere wahr, wenn Klasse existiert, andernfalls falsch.
Quiq::Perl->classExists('Quiq::Object'); ==> 1
$class->loadClass($class);
Lade Klasse $class. Im Unterschied zu Methode use() wird die Moduldatei nur zu laden versucht, wenn es den Namensraum (Package) der Klasse noch nicht gibt.
Quiq::Perl->loadClass('My::Application');
@arr | $arr = $this->baseClasses($class);
Liefere die Liste der *aller* Basisklassen der Klasse $class, einschließlich UNIVERSAL und deren Basisklassen.
Gegeben folgende Vererbungshierarchie:
Pkg6 Pkg7 \ / UNIVERSAL Pkg1 | Pkg2 / \ Pkg3 Pkg4 \ / Pkg5
Der Aufruf Quiq::Perl->baseClasses('Pkg5') liefert ein Array mit den Elementen
Pkg3 Pkg2 Pkg1 Pkg4 UNIVERSAL Pkg6 Pkg7
Die Klassen Pkg2 und Pkg1 werden nicht wiederholt.
@arr | $arr = $this->baseClassesISA($class);
Liefere die Liste der Basisklassen der Klasse $class. Jede Basisklasse kommt in der Liste genau einmal vor.
Pkg1 | Pkg2 / \ Pkg3 Pkg4 \ / Pkg5
Der Aufruf Quiq::Perl->baseClassesISA('Pkg5') liefert ein Array mit den Elementen
Pkg3 Pkg2 Pkg1 Pkg4
@arr | $arr = $this->hierarchyISA($class);
Liefere die ISA-Hierarchie der Klasse $class. Kommt eine Basisklasse in der Hierarchie mehrfach vor, erscheint sie mehrfach in der Liste.
Pkg1 | Pkg2 / \\ Pkg3 Pkg4 \ / Pkg5
Der Aufruf Quiq::Perl->hierarchyISA('Pkg5') liefert ein Array mit den Elementen
Pkg3 Pkg2 Pkg1 Pkg4 Pkg2 Pkg1
Die Basisklassen Pkg2 und Pkg1 erscheinen zweimal.
@arr | $arr = $this->subClasses($class);
Liefere die Liste der Subklassen der Klasse $class.
Der Aufruf Quiq::Perl->subClasses('Pkg1') liefert ein Array mit den Elementen:
Pkg2 Pkg3 Pkg4 Pkg5
Die Reihenfolge der Elemente ist nicht definiert.
@arr = Quiq::Perl->subClasses('Pkg1')->sort;
Liste, eingeschränkt auf Klassen, deren Name einen Regex erfüllt:
@arr = Quiq::Perl->subClasses('Pkg1')->select(qr/[45]/);
($nextClass,$nextMeth) = $this->nextMethod($class,$name,$startClass);
$classPath = $class->classNameToPath($className);
Übersetze den Klassennamen $className in den entsprechenden Klassenpfad (ohne Dateiendung) und liefere diesen zurück.
'A::B::C' => 'A/B/C'
$className = $class->classPathToName($classPath);
Übersetze Klassenpfad $classPath (ist eine Endung vorhanden, wird sie entfernt) in den entsprechenden Klassennamen und liefere diesen zurück.
'A/B/C' ==> 'A::B::C' 'A/B/C.pm' ==> 'A::B::C'
$this->createAlias($package,$sym=>$ref); $this->createAlias($sym=>$ref);
Weise dem Typeglob-Eintrag $sym in der Symboltabelle des Package $package die Referenz $ref zu. Die Methode liefert keinen Wert zurück.
Der Aufruf ist äquivalent zu:
no strict 'refs'; *{"$package\::$sym"} = $ref;
Ist $package nicht angegeben wird das Package des Aufrufers (d.h. das Package, aus dem heraus der Aufruf erfolgt) genommen.
Alias für Subroutine aus anderer Klasse:
Quiq::Perl->createAlias('MyClass',mySub=>\&MyClass1::mySub1);
Eintrag einer Closure in die Symboltabelle:
Quiq::Perl->createAlias(__PACKAGE__,mySub=>sub { <code> });
$ref = $this->createHash($package,$sym);
Erzeuge einen globalen Hash in Package $package und liefere eine Referenz diesen zurück.
Erzeuge in $class den Hash %H:
$ref = $this->createHash($class,'H');
die Referenz kann geblesst werden:
bless $ref,'Quiq::Hash';
$ref = $this->getHash($package,$name);
$ref = Quiq::Perl->getHash($package,'H');
$ref = $this->setHash($package,$name,$ref);
Setze Package-Hash mit dem Namen $name auf den von $ref referenzierten Wert, also auf %$ref und liefere eine Referenz auf die Variable zurück.
Die Methode kopiert den Wert, sie erzeugt keinen Alias!
Setze Paket-Hash 'h' auf den Wert %hash:
$ref = Quiq::Perl->setHash($package,'h',\%hash);
$ref = $this->createArray($package,$sym);
Erzeuge ein globales Array in Package $package und liefere eine Referenz dieses zurück.
Erzeuge in $class das Array @A:
$ref = Quiq::Perl->createArray($class,'A');
bless $ref,'Quiq::Array';
$ref = $this->getArray($package,$name);
$ref = Quiq::Perl->getArray($package,'A');
$ref = $this->setArray($package,$name,$ref);
Setze Package-Array mit dem Namen $name auf den von $ref referenzierten Wert, also auf @$ref und liefere eine Referenz auf die Variable zurück.
Setze Paket-Array 'a' auf den Wert @arr:
$ref = Quiq::Perl->setArray($package,'a',\@arr);
$ref = $this->setScalar($package,$name,$val);
Setze Package-Skalar mit dem Namen $name auf den Wert $val und liefere eine Referenz auf die Variable zurück.
Setze Paket-Skalar 'n' auf den Wert 99:
$ref = $this->setScalar($package,n=>99);
$this->setScalarValue($package,$name=>$val);
Setze Package-Skalar mit dem Namen $name auf den Wert $val.
$ref = Quiq::Perl->setScalarValue($package,n=>99);
$val = $this->getScalarValue($package,$name);
Ermittele Wert von Paket-Skalar 'n':
$val = Quiq::Perl->getScalarValue($package,'n');
$ref = $this->setVar($package,$sigil,$name,$ref);
Setze Paketvariable vom Typ $sigil ('$', '@' oder '%') mit dem Namen $name auf den von $ref referenzierten Wert (also $$ref (falls Skalar) oder @$ref (falls Array) oder %$ref (falls Hash)) und liefere eine Referenz auf die Variable zurück.
Die Subroutine kopiert den Wert, sie erzeugt keinen Alias!
Skalar
$ref = Quiq::Perl->setVar($package,'$','s',\99);
Array
$ref = Quiq::Perl->setVar($package,'@','a',\@arr);
Hash
$ref = Quiq::Perl->setVar($package,'%','h',\%hash);
$ref = $this->getVar($package,$sigil,$name,@opt);
Erzeuge Variable, falls sie nicht existiert.
Liefere eine Referenz auf Package-Variable $name vom Typ $sigil ('$','@' oder '%'). Existiert die Variable nicht, liefere undef.
Skalare Variable
Skalare Paketvariable, die mit "our" vereinbart sind und den Wert undef haben, werden von der Funktion nicht erkannt bzw. nicht sicher erkannt (Grund ist unklar). Mit "our" vereinbarte skalare Paketvariable mit definiertem Wert werden sicher erkannt. Workaround: Skalare Paketvariable, die mit der Methode abgefragt werden sollen, auch wenn sie den Wert undef haben, mit "use vars" vereinbaren.
$ref = $this->setSubroutine($package,$name=>$ref);
Referenz auf die Subroutine.
Füge Subroutine $ref zu Package $package unter dem Namen $name hinzu. Existiert eine Package-Subroutine mit dem Namen bereits, wird diese ersetzt.
Definition:
$ref = Quiq::Perl->setSubroutine('My::Class',m=>sub {...});
Aufruf:
My::Class->m(...);
oder
$ref->(...);
$ref = $this->getSubroutine($package,$name);
Liefere Referenz auf Subroutine $name in Package $package. Enthält das Package keine Subroutine mit dem Namen $name, liefere undef.
@paths|$pathA = $class->basicIncPaths;
Liefere die Liste der grundlegenden Suchpfade des aktuell laufenden Perl-Interpreters. Ergänzungen durch
-Ipath
PERLLIB
PERL5LIB
use lib (@paths)
usw.
sind nicht enthalten.
Die Liste entspricht dem Ergebnis des Aufrufs
$ PERLLIB= PERL5LIB= perl -le 'print join "\n",@INC'
additionalIncPaths()
incPaths()
Quiq::Perl->basicIncPaths; ==> /etc/perl /usr/local/lib/x86_64-linux-gnu/perl/5.20.2 /usr/local/share/perl/5.20.2 /usr/lib/x86_64-linux-gnu/perl5/5.20 /usr/share/perl5 /usr/lib/x86_64-linux-gnu/perl/5.20 /usr/share/perl/5.20 /usr/local/lib/site_perl .
@paths|$pathA = $class->additionalIncPaths;
Liefere die zusätzlichen Suchpfade des aktuell laufenden Perl-Programms, also die Suchpfade, die über die grundlegenden Suchpfade des Perl_interpreters hinausgehen.
basicIncPaths()
@paths|$pathA = $class->incPaths;
Liefere alle Suchpfade des aktuell laufenden Perl-Programms, also die Werte des @INC-Arrays Im Skalar-Kontext liefere eine Referenz auf das Array.
$pod = $this->getPod($file); $pod = $this->getPod(\$text); ($pod,$encoding) = $this->getPod($file); ($pod,$encoding) = $this->getPod(\$text);
Lies den POD-Code aus Datei $file bzw. Quelltext $text und liefere diesen zurück. Ist ein Encoding definiert, dekodiere den gelieferten POD-Code entsprechend. Im Array-Kontext liefere zusätzlich zum POD-Code das Encoding.
$this->getPodValues($file,@keyRef); $this->getPodValues(\$text,@keyRef);
$newCode = $this->removePod($code); $this->removePod(\$code);
Entferne alle POD-Abschnitte aus dem Quelltext $code und liefere den resultierenden Quelltext zurück. Wird eine Referenz auf den Quelltext übergeben, erfolgt die Manipulation in-place.
Auf den POD-Abschnitt folgende Leerzeilen (die außerhalb des POD-Code liegen) werden ebenfalls entfernt.
1.174
Frank Seitz, http://fseitz.de/
Copyright (C) 2020 Frank Seitz
This code is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
To install Quiq, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Quiq
CPAN shell
perl -MCPAN -e shell install Quiq
For more information on module installation, please visit the detailed CPAN module installation guide.