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

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15103 -->
<!-- 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 API ist wie folgt:
            </para>

            <programlisting role="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 <code>_init()</code> auf (welches für eine konkrete
                erweiterte Klasse für die Implementation leer gelassen ist), übergibt dann
                den <code>$options</code> Parameter an <code>setOptions()</code> und ruft
                zuletzt <code>_prepare()</code> auf (welches auch von der erweiternden Klasse
                implementiert werden muß).
            </para>

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

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

            <para>
                <code>setSourceContent()</code> und <code>getSourceContent()</code> 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 API ist wie folgt:
            </para>

            <programlisting role="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 API ist
                wie folgt:
            </para>

            <programlisting role="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 <code>generate()</code>
                aufruft.
            </para>

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

            <programlisting role="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 PHP Klassen
                gedacht. Die Basisfunktionalität ist nur die Erstellung der PHP Klasse selbst,
                sowie optional den betreffenden PHP 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 API ist wie folgt:
            </para>

            <programlisting role="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 <code>setProperty()</code> 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 <code>setMethod()</code> 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 <code>setDocBlock()</code> 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 PHP 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 <code>setTag()</code> und
                <code>setTags()</code> Methoden gesetzt werden; diese nehmen entweder ein Array an
                das 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 API ist wie folgt:
            </para>

            <programlisting role="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 PHP 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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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 API dieser Klasse ist wie folgt:
            </para>

            <programlisting role="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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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 PHP Code enthalten wird. Die Datei kann Klassen oder
                eigenen PHP 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 API der Klasse ist wie folgt:
            </para>


            <programlisting role="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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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 <code>setParameter()</code> oder
                <code>setParameters()</code> 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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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 generate()
}
]]></programlisting>
        </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 API der Klasse ist wie folgt:
            </para>

            <programlisting role="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>