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

    <sect2 id="zend.codegenerator.reference.abstracts">
        <title>Clases Abstractas e Interfaces</title>

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

            <para>
                La clase base desde la cual heredan todos las clases
                CodeGenerator proporciona la
                funcionalidad mínima necesaria. Su
                <acronym>API</acronym>
                es la siguiente:
            </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>
                El constructor primero llama a
                <methodname>_init()</methodname>
                (que se deja vacía para
                implementar extenciones a clases concretas), se pasa entonces
                el
                parámetro
                <varname>$options</varname>
                a
                <methodname>setOptions()</methodname>
                , y finalmente se llama
                a
                <methodname>_prepare()</methodname>
                (nuevamente, a ser
                implementada por extensión de una clase)
            </para>

            <para>
                Al igual que la mayoría de las clases en Zend Framework,
                <methodname>setOptions()</methodname>
                compara una opción
                clave con setters existentes en la clase, y pasa el valor de ese
                método si lo encuentra.
            </para>

            <para>
                <methodname>__toString()</methodname>
                es marcado como final, y
                proxies a
                <methodname>generate()</methodname>
                .
            </para>

            <para>
                <methodname>setSourceContent()</methodname>
                y
                <methodname>getSourceContent()</methodname>
                están destinados
                ya sea para fijar el valor por defecto del contenido para el
                código a
                ser generado, o para sustituir dicho contenido una vez
                que se completen todas las
                tareas de generación.
            </para>
        </sect3>

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

            <para>
                <classname>Zend_CodeGenerator_Php_Abstract</classname>
                extiende
                <classname>Zend_CodeGenerator_Abstract</classname>
                , y añade
                algunas propiedades para localizar su contenido si es que ha
                cambiado, así
                como el nivel de identación que debe aparecer
                antes del contenido generado. Su
                <acronym>API</acronym>
                es la
                siguiente:
            </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>
                es
                una clase base para generar los miembros de clase -- propiedades
                y métodos -- y
                brinda accesos y mutadores para establecer
                visibilidad; ya sea el miembro abstracto o
                no, estático o
                definitivo; y el nombre del miembro. Su
                <acronym>API</acronym>
                es la siguiente:
            </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>Clases Concretas de CodeGenerator</title>

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

            <para>
                <classname>Zend_CodeGenerator_Php_Body</classname>
                se destina
                para generar código procedural arbitrario para incluir dentro de
                un
                archivo. Como tal, usted simplemente establece contenidos
                para el objeto, y éste
                devolverá el contenido cuando usted
                invoque a
                <methodname>generate()</methodname>
                .
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                Está
                destinado a generar clases
                <acronym>PHP</acronym>
                . La
                funcionalidad básica sólo genera la clase
                <acronym>PHP</acronym>
                en si misma, así como opcionalmente el
                <acronym>PHP</acronym>
                DocBlock. Las clases pueden implementarse o heredarse de otras
                clases, y pueden ser
                marcadas como abstractas. Utilizando otras
                clases generadoras de código, también
                puede agregar constantes
                de clase, propiedades y métodos.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                El método
                <methodname>setProperty()</methodname>
                acepta un
                array de información que puede ser utilizada para generar una
                instancia
                <classname>Zend_CodeGenerator_Php_Property</classname>
                -- o simplemente una instancia de
                <classname>Zend_CodeGenerator_Php_Property</classname>
                .
                Análogamente,
                <methodname>setMethod()</methodname>
                acepta o un
                array de información para generar una instancia de
                <classname>Zend_CodeGenerator_Php_Method</classname>
                o una
                instancia concreta de esa clase.
            </para>

            <para>
                Se debe observar que
                <methodname>setDocBlock()</methodname>
                espera una instancia de
                <classname>Zend_CodeGenerator_Php_DocBlock</classname>
                .
            </para>
        </sect3>

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

            <para>
                <classname>Zend_CodeGenerator_Php_Docblock</classname>
                puede ser
                utilizada para generar
                <acronym>PHP</acronym>
                docblocks
                arbitrarios, incluidas todas las características estándar de
                docblock:
                descripciones cortas y largas y además los tags de
                anotaciones.
            </para>

            <para>
                Los tags de anotación pueden establecerse utilizando los
                métodos
                <methodname>setTag()</methodname>
                y
                <methodname>setTags()</methodname>
                ; cada una de estas toman
                o un array describiendo el tag que puede ser pasado al
                constructor
                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname>
                ,
                o una instancia de esa clase.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                está
                destinado a crear tags de anotaciones arbitrarias para su
                inclusión en
                <acronym>PHP</acronym>
                docblocks. Se espera que los
                tags (etiquetas) contengan un nombre (la porción que
                sigue
                inmediatamente después del símbolo '@') y una descripción (todo
                lo que sigue
                después del nombre del tag).
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                es una versión especializada de
                <classname>Zend_CodeGenerator_Php_DocBlock_Tag</classname>
                ,
                y representa un parámetro del método. El nombre del tag es por
                lo tanto ("param"),
                pero debido al formato de este tag de
                anotación, es necesaria información adicional a
                fin de
                generarla: el nombre del parámetro y el tipo de datos que
                representa.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                Al igual la variante del tag docblock,
                <classname>Zend_CodeGenerator_Php_Docblock_Tab_Return</classname>
                es una variante de un tag de anotación para representar el valor
                de retorno del
                método. En este caso, el nombre del tag de
                anotación es conocido ("return"), pero
                requiere un tipo de
                retorno.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                se utiliza
                para generar el contenido íntegro de un archivo que contiene
                código
                <acronym>PHP</acronym>
                . El archivo puede contener clases
                o código
                <acronym>PHP</acronym>
                arbitrario, así como un archivo
                de nivel docblock si así lo desea.
            </para>

            <para>
                Cuando se agregan clases al archivo, necesitará pasar o un
                array de información para
                pasar al constructor
                <classname>Zend_CodeGenerator_Php_Class</classname>
                , o una
                instancia de esa clase. De manera similar, con docblocks, usted
                tendrá que
                pasar información para que lo consuma el constructor
                <classname>Zend_CodeGenerator_Php_Docblock</classname>
                o una
                instancia de la clase.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                es usado internamente por
                <classname>Zend_CodeGenerator_Php_Class</classname>
                para
                seguir la pista de los los miembros de la clase -- a propiedades
                y métodos por
                igual. Estos están indexados por nombre,
                utilizando las instancias concretas de los
                miembros como
                valores.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                describe un
                método de clase, y puede generar tanto el código y el docblock
                para el
                método. La visibilidad y condición estática, abstracta,
                o se puede indicar como
                final, por su clase padre,
                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>
                .
                Finalmente, pueden especificarse los parámetros y valor de
                retorno para el método.
            </para>

            <para>
                Pueden establecerse los parámetros usando
                <methodname>setParameter()</methodname>
                o
                <methodname>setParameters()</methodname>
                . En cada caso, un
                parámetro debe ser un array de información para pasar al
                constructor
                <classname>Zend_CodeGenerator_Php_Parameter</classname>
                o
                una instancia de esa clase.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                puede
                ser utilizada para especificar parámetros del método. Cada
                parámetro puede tener
                una posición (si no están especificados,
                se usarán en el orden que estén registrados
                en el método), son
                oblogatorios un valor por defecto, un tipo de datos y un nombre
                de
                parámetro.
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
                There are several problems that might occur when trying to set <constant>NULL</constant>, booleans or
                arrays as default values. For this the value holder object
                <classname>Zend_CodeGenerator_Php_ParameterDefaultValue</classname>
                can be used,
                for example:
            </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>
                Internally
                <methodname>setDefaultValue()</methodname>
                also converts the values
                which can't be expressed in
                <acronym>PHP</acronym>
                into the value holder.
            </para>

        </sect3>

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

            <para>
                <classname>Zend_CodeGenerator_Php_Property</classname>
                describe
                una propiedad de clase, que puede ser tanto una constante o una
                variable. En
                cada caso, la propiedad puede tener un valor
                predeterminado asociado con ella.
                Además, la visibilidad de las
                propiedades de la variable puede ser establecida por la
                clase
                padre,
                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>
                .
            </para>

            <para>
                La
                <acronym>API</acronym>
                de la clase es la siguiente:
            </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>
