repo_zf1/documentation/manual/de/module_specs/Zend_CodeGenerator-Reference.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect1 id="zend.codegenerator.reference">
    <title>Zend_CodeGenerator Referenz</title>

    <sect2 id="zend.codegenerator.reference.abstracts">
        <title>Abstrakte Klassen und Interfaces</title>

        <sect3 id="zend.codegenerator.reference.abstracts.abstract">
            <title>Zend_CodeGenerator_Abstract</title>

            <para>
                Die Basisklasse von der alle CodeGenerator Klassen abgeleitet sind und die
                minimal notwendige Funktionalität anbietet. Dessen <acronym>API</acronym> ist wie
                folgt:
            </para>

            <programlisting language="php"><![CDATA[
abstract class Zend_CodeGenerator_Abstract
{
    final public function __construct(Array $options = array())
    public function setOptions(Array $options)
    public function setSourceContent($sourceContent)
    public function getSourceContent()
    protected function _init()
    protected function _prepare()
    abstract public function generate();
    final public function __toString()
}
]]></programlisting>

            <para>
                Der Constructor ruft zuerst <methodname>_init()</methodname> auf (welches für eine
                konkrete erweiterte Klasse für die Implementation leer gelassen ist), übergibt dann
                den <varname>$options</varname> Parameter an <methodname>setOptions()</methodname>
                und ruft zuletzt <methodname>_prepare()</methodname> auf (welches auch von der
                erweiternden Klasse implementiert werden muß).
            </para>

            <para>
                Wie die meisten Klassen im Zend Framework, vergleicht
                <methodname>setOptions()</methodname> den Schlüssel einer Option mit den in der
                Klasse existierenden Settern, und übergibt den Wert an die gefundene Methode.
            </para>

            <para>
                <methodname>__toString()</methodname> ist als final markiert, und leitet auf
                <methodname>generate()</methodname> weiter.
            </para>

            <para>
                <methodname>setSourceContent()</methodname> und
                <methodname>getSourceContent()</methodname> sind dazu vergesehen entweder den
                Standardinhalt für den zu erzeugenden Code zu setzen, oder um gesetzte Inhalte zu
                ersetzen sobald alle Arbeiten der Erzeugung beendet wurden.
            </para>
        </sect3>

        <sect3 id="zend.codegenerator.reference.abstracts.php-abstract">
            <title>Zend_CodeGenerator_Php_Abstract</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Abstract</classname> erweitert
                <classname>Zend_CodeGenerator_Abstract</classname>, und fügt einige Eigenschaften
                hinzu für das Verfolgen ob Inhalte geändert wurden sowie der Anzahl an Einrückungen
                die vorhanden sein sollten bevor Inhalte erzeugt werden. Die <acronym>API</acronym>
                ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
abstract class Zend_CodeGenerator_Php_Abstract
    extends Zend_CodeGenerator_Abstract
{
    public function setSourceDirty($isSourceDirty = true)
    public function isSourceDirty()
    public function setIndentation($indentation)
    public function getIndentation()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.abstracts.php-member-abstract">
            <title>Zend_CodeGenerator_Php_Member_Abstract</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname> ist eine Basisklasse
                für die Erstellung von Klassen-Member -- Eigenschaften und Methoden -- und bietet
                Zugriffs- und Änderungsmethoden für die Ausführung der Sichtbarkeit; ob ein
                Member Abstrakt, Statisch, oder Final ist; und der Name des Members. Die
                <acronym>API</acronym> ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
abstract class Zend_CodeGenerator_Php_Member_Abstract
    extends Zend_CodeGenerator_Php_Abstract
{
    public function setAbstract($isAbstract)
    public function isAbstract()
    public function setStatic($isStatic)
    public function isStatic()
    public function setVisibility($visibility)
    public function getVisibility()
    public function setName($name)
    public function getName()
}
]]></programlisting>
        </sect3>
    </sect2>

    <sect2 id="zend.codegenerator.reference.concrete">
        <title>Konkrete CodeGenerator Klassen</title>

        <sect3 id="zend.codegenerator.reference.concrete.php-body">
            <title>Zend_CodeGenerator_Php_Body</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Body</classname> ist dazu gedacht generellen
                prozeduralen Code in einer Datei einzufügen. Als solches kann man einfach den Inhalt
                für das Objekt setzen, und es wird den Inhalt zurückgeben wenn man
                <methodname>generate()</methodname> aufruft.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Body extends Zend_CodeGenerator_Php_Abstract
{
    public function setContent($content)
    public function getContent()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-class">
            <title>Zend_CodeGenerator_Php_Class</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Class</classname> ist für die Erstellung von
                <acronym>PHP</acronym> Klassen gedacht. Die Basisfunktionalität ist nur die
                Erstellung der <acronym>PHP</acronym> Klasse selbst, sowie optional den
                betreffenden <acronym>PHP</acronym> DocBlock. Klassen können von anderen Klassen
                abgeleitet sein, oder diese Implementieren, und können als Abstrakt markiert
                sein. Bei Verwendung von anderen CodeGenerator Klassen kann man auch
                Klassenkonstanten, Eigenschaften und Methoden hinzufügen.
            </para>

            <para>
                Die <acronym>API</acronym> ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Class extends Zend_CodeGenerator_Php_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Class $reflectionClass
    )
    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
    public function getDocblock()
    public function setName($name)
    public function getName()
    public function setAbstract($isAbstract)
    public function isAbstract()
    public function setExtendedClass($extendedClass)
    public function getExtendedClass()
    public function setImplementedInterfaces(Array $implementedInterfaces)
    public function getImplementedInterfaces()
    public function setProperties(Array $properties)
    public function setProperty($property)
    public function getProperties()
    public function getProperty($propertyName)
    public function setMethods(Array $methods)
    public function setMethod($method)
    public function getMethods()
    public function getMethod($methodName)
    public function hasMethod($methodName)
    public function isSourceDirty()
    public function generate()
}
]]></programlisting>

            <para>
                Die <methodname>setProperty()</methodname> Methode akzeptiert ein Array von
                Informationen, die verwendet werden können um eine Instanz von
                <classname>Zend_CodeGenerator_Php_Property</classname> zu erstellen -- oder einfach
                eine Instanz von <classname>Zend_CodeGenerator_Php_Property</classname> selbst.
                Genauso akzeptiert <methodname>setMethod()</methodname> entweder ein Array von
                Information für die Erstellung einer
                <classname>Zend_CodeGenerator_Php_Method</classname> Instanz oder eine konkrete
                Instanz dieser Klasse.
            </para>

            <para>
                Beachte das <methodname>setDocBlock()</methodname> eine Instanz von
                <classname>Zend_CodeGenerator_Php_DocBlock</classname> erwartet.
            </para>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-docblock">
            <title>Zend_CodeGenerator_Php_Docblock</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Docblock</classname> kann verwendet werden um
                <acronym>PHP</acronym> DocBlocks zu erstellen, inklusive aller standardmäßigen
                DocBlock Features: Kurz- und Langbeschreibung sowie zusätzliche Tags.
            </para>

            <para>
                Zusätzliche Tags können durch Verwendung der <methodname>setTag()</methodname> und
                <methodname>setTags()</methodname> Methoden gesetzt werden; diese nehmen entweder
                ein Array an dass das Tag beschreibt das an den
                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname> Contructor übergeben
                wird, oder eine Instanz dieser Klasse selbst.
            </para>

            <para>
                Die <acronym>API</acronym> ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Docblock extends Zend_CodeGenerator_Php_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Docblock $reflectionDocblock
    )
    public function setShortDescription($shortDescription)
    public function getShortDescription()
    public function setLongDescription($longDescription)
    public function getLongDescription()
    public function setTags(Array $tags)
    public function setTag($tag)
    public function getTags()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag">
            <title>Zend_CodeGenerator_Php_Docblock_Tag</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname> ist für die Erstellung
                von eigenen Tags, zum Einfügen in <acronym>PHP</acronym> DocBlocks, gedacht. Von
                Tags wird erwartet das Sie einen Namen enthalten (Der Teil der unmittelbar dem '@'
                Symbol folgt) und eine Beschreibung (alles das dem Tag Namen folgt).
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Docblock_Tag
    extends Zend_CodeGenerator_Php_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Docblock_Tag $reflectionTag
    )
    public function setName($name)
    public function getName()
    public function setDescription($description)
    public function getDescription()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-param">
            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Param</title>

            <para>
                <classname>Zend_CodeGenerator_Php_DocBlock_Tag_Param</classname> ist eine spezielle
                Version von <classname>Zend_CodeGenerator_Php_DocBlock_Tag</classname>, und
                repräsentiert einen Parameter einer Methode. Das TagName ist hierbei bekannt
                ("param"), aber durch die Form des Tags, werden zusätzliche Informationen benötigt
                um Ihn zu erzeugen: den Namen des Parameter und den Datentyp den dieser
                repräsentiert.
            </para>

            <para>
                Die <acronym>API</acronym> dieser Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Docblock_Tag_Param
    extends Zend_CodeGenerator_Php_Docblock_Tag
{
    public static function fromReflection(
        Zend_Reflection_Docblock_Tag $reflectionTagParam
    )
    public function setDatatype($datatype)
    public function getDatatype()
    public function setParamName($paramName)
    public function getParamName()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-return">
            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Return</title>

            <para>
                Wie die Variante des Param DocBlock Tags ist
                <classname>Zend_CodeGenerator_Php_Docblock_Tab_Return</classname> eine Variante
                eines Tags für die Darstellung eines Rückgabewerts einer Methode. In diesem Fall ist
                der Name des Tags bekannt ("return"), aber es benötigt einen Rückgabetyp.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Docblock_Tag_Param
    extends Zend_CodeGenerator_Php_Docblock_Tag
{
    public static function fromReflection(
        Zend_Reflection_Docblock_Tag $reflectionTagReturn
    )
    public function setDatatype($datatype)
    public function getDatatype()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-file">
            <title>Zend_CodeGenerator_Php_File</title>

            <para>
                <classname>Zend_CodeGenerator_Php_File</classname> wird verwendet um den kompletten
                Inhalt einer Datei zu erstellen die <acronym>PHP</acronym> Code enthalten wird. Die
                Datei kann Klassen oder eigenen <acronym>PHP</acronym> Code enthalten, und wenn
                gewünscht einen Datei-Level Docblock.
            </para>

            <para>
                Wenn der Datei Klassen hinzugefügt werden, muß man entweder ein Array von
                Informationen übergeben die an den Constructor von
                <classname>Zend_CodeGenerator_Php_Class</classname> übergeben werden, oder eine
                Instanz dieser Klasse. Genau wie bei den DocBlocks, muß man Informationen für den
                Constructor von <classname>Zend_CodeGenerator_Php_Docblock</classname> übergeben die
                verwendet werden, oder eine Instanz dieser Klasse.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_File extends Zend_CodeGenerator_Php_Abstract
{
    public static function fromReflectedFilePath(
        $filePath,
        $usePreviousCodeGeneratorIfItExists = true,
        $includeIfNotAlreadyIncluded = true)
    public static function fromReflection(Zend_Reflection_File $reflectionFile)
    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
    public function getDocblock()
    public function setRequiredFiles($requiredFiles)
    public function getRequiredFiles()
    public function setClasses(Array $classes)
    public function getClass($name = null)
    public function setClass($class)
    public function setFilename($filename)
    public function getFilename()
    public function getClasses()
    public function setBody($body)
    public function getBody()
    public function isSourceDirty()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-member-container">
            <title>Zend_CodeGenerator_Php_Member_Container</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Member_Container</classname> wird intern von
                <classname>Zend_CodeGenerator_Php_Class</classname> verwendet um die Klassenmember
                zu erheben -- Eigenschaften sowie Methoden. Diese werden durch den Namen indiziert,
                indem die konkrete Instanz des Members als Wert verwendet wird.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Member_Container extends ArrayObject
{
    public function __construct($type = self::TYPE_PROPERTY)
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-method">
            <title>Zend_CodeGenerator_Php_Method</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Method</classname> beschreibt eine Klassenmethode,
                und kann sowohl Code als auch den DocBlock für diese Methode erstellen. Die
                Sichtbarkeit und der Status als Statisch, Abstrakt, oder Final kann, über die
                Eltern-Klasse, <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>,
                angegeben werden. Letztendlich können die Parameter und Rückgabewerte für die
                Methode spezifiziert werden.
            </para>

            <para>
                Parameter könnnen durch Verwendung von <methodname>setParameter()</methodname> oder
                <methodname>setParameters()</methodname> gesetzt werden. In jedem Fall, sollte der
                Parameter entweder ein Array von Informationen sein die an den Constructor von
                <classname>Zend_CodeGenerator_Php_Parameter</classname> übergeben werden, oder eine
                Instanz dieser Klasse.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Method
    extends Zend_CodeGenerator_Php_Member_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Method $reflectionMethod
    )
    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
    public function getDocblock()
    public function setFinal($isFinal)
    public function setParameters(Array $parameters)
    public function setParameter($parameter)
    public function getParameters()
    public function setBody($body)
    public function getBody()
    public function generate()
}
]]></programlisting>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-parameter">
            <title>Zend_CodeGenerator_Php_Parameter</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Parameter</classname> kann verwendet werden um
                Methodenparameter zu spezifizieren. Jeder Parameter kann eine Position haben
                (wenn nicht spezifiziert wird die Reihenfolge in der diese spezifiziert werden
                verwendet), einen Standardwert, und einen Datentyp; ein Parametername wird
                benötigt.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Parameter extends Zend_CodeGenerator_Php_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Parameter $reflectionParameter
    )
    public function setType($type)
    public function getType()
    public function setName($name)
    public function getName()
    public function setDefaultValue($defaultValue)
    public function getDefaultValue()
    public function setPosition($position)
    public function getPosition()
    public function getPassedByReference()
    public function setPassedByReference($passedByReference)
    public function generate()
}
]]></programlisting>

            <para>
                Es gibt einige Probleme die auftreten können wenn man versucht
                <constant>NULL</constant>, boolsche Werte oder Arrays als Standardwerte zu setzen.
                Hierfür kann das Wert-Halte-Objekt
                <classname>Zend_CodeGenerator_Php_ParameterDefaultValue</classname> verwendet
                werden. Zum Beispiel:
            </para>

            <programlisting language="php"><![CDATA[
$parameter = new Zend_CodeGenerator_Php_Parameter();
$parameter->setDefaultValue(
    new Zend_CodeGenerator_Php_Parameter_DefaultValue("null")
);
$parameter->setDefaultValue(
    new Zend_CodeGenerator_Php_Parameter_DefaultValue("array('foo', 'bar')")
);
]]></programlisting>

            <para>
                Intern konvertiert <methodname>setDefaultValue()</methodname> die Werte, welche in
                <acronym>PHP</acronym> nicht ausgedrückt werden können, in den Werte-Halter.
            </para>
        </sect3>

        <sect3 id="zend.codegenerator.reference.concrete.php-property">
            <title>Zend_CodeGenerator_Php_Property</title>

            <para>
                <classname>Zend_CodeGenerator_Php_Property</classname> beschreibt die Eigenschaft
                einer Klasse, welche entweder eine Konstante oder eine Variable sein kann. In jedem
                Fall, kann der Eigenschaft ein optionaler Standardwert assoziiert werden.
                Zusätzlich kann die Sichtbarkeit von variablen Eigenschaften über die Elternklasse
                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname> gesetzt werden.
            </para>

            <para>
                Die <acronym>API</acronym> der Klasse ist wie folgt:
            </para>

            <programlisting language="php"><![CDATA[
class Zend_CodeGenerator_Php_Property
    extends Zend_CodeGenerator_Php_Member_Abstract
{
    public static function fromReflection(
        Zend_Reflection_Property $reflectionProperty
    )
    public function setConst($const)
    public function isConst()
    public function setDefaultValue($defaultValue)
    public function getDefaultValue()
    public function generate()
}
]]></programlisting>
        </sect3>
    </sect2>
</sect1>