repo_zf1Php7/documentation/manual/es/module_specs/Zend_CodeGenerator-Reference.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 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 API es la siguiente:
            </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>
                El constructor primero llama a <code>_init()</code>
                (que se deja vacía para implementar extenciones a clases
                concretas), se pasa entonces el parámetro <code>$options</code>
                a <code>setOptions()</code>, y finalmente se llama a
                <code>_prepare()</code> (nuevamente, a ser implementada por
                extensión de una clase)
            </para>

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

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

            <para>
                <code>setSourceContent()</code> y
                <code>getSourceContent()</code> 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 API es la siguiente:
            </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>
                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 API es la siguiente:
            </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>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 <code>generate()</code>.
            </para>

            <para>
                La API de la clase es la siguiente:
            </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> Está
                destinado a generar clases PHP. La funcionalidad básica sólo
                genera la clase PHP en si misma, así como opcionalmente el PHP
                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 API de la clase es la siguiente:
            </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>
                El método <code>setProperty()</code> 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, <code>setMethod()</code> 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 <code>setDocBlock()</code> 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 PHP 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
                <code>setTag()</code> y <code>setTags()</code>; 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 API de la clase es la siguiente:
            </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> está
                destinado a crear tags de anotaciones arbitrarias
                para su inclusión en PHP 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 API de la clase es la siguiente:
            </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>
                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 API de la clase es la siguiente:
            </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>
                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 API de la clase es la siguiente:
            </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> se utiliza
                para generar el contenido íntegro de un archivo que contiene
                código PHP. El archivo puede contener clases o código PHP
                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 API de la clase es la siguiente:
            </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>
                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 API de la clase es la siguiente:
            </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> 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
                <code>setParameter()</code> o <code>setParameters()</code>.
                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 API de la clase es la siguiente:
            </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>
                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 API de la clase es la siguiente:
            </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> 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 API de la clase es la siguiente:
            </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>