

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: Iterator.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#============================================================= -*-Perl-*-
#
# Template::Iterator
#
# DESCRIPTION
#
#   Module defining an iterator class which is used by the FOREACH
#   directive for iterating through data sets.  This may be
#   sub-classed to define more specific iterator types.
#
# AUTHOR
#   Andy Wardley   &lt;abw@wardley.org&gt;
#
# COPYRIGHT
#   Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.
#
#   This module is free software; you can redistribute it and/or
#   modify it under the same terms as Perl itself.
#
#============================================================================

package Template::Iterator;

use strict;
use warnings;
use base &#039;Template::Base&#039;;
use Template::Constants;
use Template::Exception;
use Scalar::Util qw(blessed);

use constant ODD  =&gt; &#039;odd&#039;;
use constant EVEN =&gt; &#039;even&#039;;

our $VERSION = &#039;3.106&#039;;
our $DEBUG   = 0 unless defined $DEBUG;
our $AUTOLOAD;

#========================================================================
#                      -----  CLASS METHODS -----
#========================================================================

#------------------------------------------------------------------------
# new(\@target, \%options)
#
# Constructor method which creates and returns a reference to a new
# Template::Iterator object.  A reference to the target data (array
# or hash) may be passed for the object to iterate through.
#------------------------------------------------------------------------

sub new {
    my $class  = shift;
    my $data   = shift || [ ];
    my $params = shift || { };

    if (ref $data eq &#039;HASH&#039;) {
        # map a hash into a list of { key =&gt; ???, value =&gt; ??? } hashes,
        # one for each key, sorted by keys
        $data = [
            map { { key =&gt; $_, value =&gt; $data-&gt;{ $_ } } }
            sort keys %$data
        ];
    }
    elsif (blessed($data) &amp;&amp; $data-&gt;can(&#039;as_list&#039;)) {
        $data = $data-&gt;as_list();
    }
    elsif (ref $data ne &#039;ARRAY&#039;) {
        # coerce any non-list data into an array reference
        $data  = [ $data ] ;
    }

    bless {
        _DATA  =&gt; $data,
        _ERROR =&gt; &#039;&#039;,
    }, $class;
}


#========================================================================
#                   -----  PUBLIC OBJECT METHODS -----
#========================================================================

#------------------------------------------------------------------------
# get_first()
#
# Initialises the object for iterating through the target data set.  The
# first record is returned, if defined, along with the STATUS_OK value.
# If there is no target data, or the data is an empty set, then undef
# is returned with the STATUS_DONE value.
#------------------------------------------------------------------------

sub get_first {
    my $self  = shift;
    my $data  = $self-&gt;{ _DATA };

    $self-&gt;{ _DATASET } = $self-&gt;{ _DATA };
    my $size = scalar @$data;
    my $index = 0;

    return (undef, Template::Constants::STATUS_DONE) unless $size;

    # initialise various counters, flags, etc.
    @$self{ qw( SIZE MAX INDEX COUNT FIRST LAST ) }
            = ( $size, $size - 1, $index, 1, 1, $size &gt; 1 ? 0 : 1, undef );
    @$self{ qw( PREV NEXT ) } = ( undef, $self-&gt;{ _DATASET }-&gt;[ $index + 1 ]);

    return $self-&gt;{ _DATASET }-&gt;[ $index ];
}


#------------------------------------------------------------------------
# get_next()
#
# Called repeatedly to access successive elements in the data set.
# Should only be called after calling get_first() or a warning will
# be raised and (undef, STATUS_DONE) returned.
#------------------------------------------------------------------------

sub get_next {
    my ( $max, $index ) = @{ $_[0] }{qw( MAX INDEX )};

    # warn about incorrect usage
    if ( !defined $index ) {
        my ( $pack, $file, $line ) = caller();
        warn(&quot;iterator get_next() called before get_first() at $file line $line\n&quot;);
        return ( undef, Template::Constants::STATUS_DONE );    ## RETURN ##
    }

    # if there&#039;s still some data to go...
    elsif ( $index &gt;= $max ) {
        return ( undef, Template::Constants::STATUS_DONE );    ## RETURN ##
    }

    my $self = shift;
    my $dataset = $self-&gt;{_DATASET};

    $index++;

    # update counters and flags
    @$self{qw( INDEX COUNT FIRST LAST PREV NEXT )} = (
        $index,                                            # INDEX
        $index + 1,                                        # COUNT
        0,                                                 # FIRST
        $index == $max ? 1 : 0,                            # LAST
        @$dataset[ $index - 1, $index + 1 ]                # PREV, NEXT
    );

    return $dataset-&gt;[ $index ];                           ## RETURN ##
}


#------------------------------------------------------------------------
# get_all()
#
# Method which returns all remaining items in the iterator as a Perl list
# reference.  May be called at any time in the life-cycle of the iterator.
# The get_first() method will be called automatically if necessary, and
# then subsequent get_next() calls are made, storing each returned
# result until the list is exhausted.
#------------------------------------------------------------------------

sub get_all {
    my $self = shift;
    my ($max, $index) = @$self{ qw( MAX INDEX ) };
    my @data;

    # handle cases where get_first() has yet to be called.
    unless (defined $index) {
        my ($first, $status) = $self-&gt;get_first;

        # refresh $max and $index, after get_first updates MAX and INDEX
        ($max, $index) = @$self{ qw( MAX INDEX ) };

        # empty lists are handled here.
        if ($status &amp;&amp; $status == Template::Constants::STATUS_DONE) {
            return (undef, Template::Constants::STATUS_DONE);   ## RETURN ##
        }

        push @data, $first;

        ## if there&#039;s nothing left in the iterator, return the single value.
        unless ($index &lt; $max) {
            return \@data;
        }
    }

    # if there&#039;s still some data to go...
    if ($index &lt; $max) {
        $index++;
        push @data, @{ $self-&gt;{ _DATASET } } [ $index..$max ];

        # update counters and flags
        @$self{ qw( INDEX COUNT FIRST LAST ) }
        = ( $max, $max + 1, 0, 1 );

        return \@data;                                      ## RETURN ##
    }
    else {
        return (undef, Template::Constants::STATUS_DONE);   ## RETURN ##
    }
}

sub odd {
    shift-&gt;{ COUNT } % 2 ? 1 : 0
}

sub even {
    shift-&gt;{ COUNT } % 2 ? 0 : 1
}

sub parity {
    shift-&gt;{ COUNT } % 2 ? ODD : EVEN;
}

sub index {
    return $_[0]-&gt;{INDEX};
}

sub count {
    return $_[0]-&gt;{COUNT};
}

sub number { # This is here for backward compatibility per sub AUTOLOAD
    return $_[0]-&gt;{COUNT};
}

sub first {
    return $_[0]-&gt;{FIRST};
}

sub last {
    return $_[0]-&gt;{LAST};
}

sub size {
    return $_[0]-&gt;{SIZE};
}

#------------------------------------------------------------------------
# AUTOLOAD
#
# Provides access to internal fields (e.g. prev, next, etc)
#------------------------------------------------------------------------

sub AUTOLOAD {
    my $self = shift;
    my $item = $AUTOLOAD;
    $item =~ s/.*:://;
    return if $item eq &#039;DESTROY&#039;;

    # alias NUMBER to COUNT for backwards compatibility
    $item = &#039;COUNT&#039; if CORE::index(uc $item,&#039;NUMBER&#039;) &gt; -1;

    return $self-&gt;{ uc $item };
}

1;

__END__

=head1 NAME

Template::Iterator - Data iterator used by the FOREACH directive

=head1 SYNOPSIS

    my $iter = Template::Iterator-&gt;new(\@data, \%options);

=head1 DESCRIPTION

The C&lt;Template::Iterator&gt; module defines a generic data iterator for use
by the C&lt;FOREACH&gt; directive.

It may be used as the base class for custom iterators.

=head1 PUBLIC METHODS

=head2 new($data)

Constructor method.  A reference to a list of values is passed as the
first parameter.  Subsequent calls to L&lt;get_first()&gt; and L&lt;get_next()&gt; calls
will return each element from the list.

    my $iter = Template::Iterator-&gt;new([ &#039;foo&#039;, &#039;bar&#039;, &#039;baz&#039; ]);

The constructor will also accept a reference to a hash array and will
expand it into a list in which each entry is a hash array containing
a &#039;C&lt;key&gt;&#039; and &#039;C&lt;value&gt;&#039; item, sorted according to the hash keys.

    my $iter = Template::Iterator-&gt;new({
        foo =&gt; &#039;Foo Item&#039;,
        bar =&gt; &#039;Bar Item&#039;,
    });

This is equivalent to:

    my $iter = Template::Iterator-&gt;new([
        { key =&gt; &#039;bar&#039;, value =&gt; &#039;Bar Item&#039; },
        { key =&gt; &#039;foo&#039;, value =&gt; &#039;Foo Item&#039; },
    ]);

When passed a single item which is not an array reference, the constructor
will automatically create a list containing that single item.

    my $iter = Template::Iterator-&gt;new(&#039;foo&#039;);

This is equivalent to:

    my $iter = Template::Iterator-&gt;new([ &#039;foo&#039; ]);

Note that a single item which is an object based on a blessed ARRAY
references will NOT be treated as an array and will be folded into
a list containing that one object reference.

    my $list = bless [ &#039;foo&#039;, &#039;bar&#039; ], &#039;MyListClass&#039;;
    my $iter = Template::Iterator-&gt;new($list);

equivalent to:

    my $iter = Template::Iterator-&gt;new([ $list ]);

If the object provides an C&lt;as_list()&gt; method then the L&lt;Template::Iterator&gt;
constructor will call that method to return the list of data.  For example:

    package MyListObject;

    sub new {
        my $class = shift;
        bless [ @_ ], $class;
    }

    package main;

    my $list = MyListObject-&gt;new(&#039;foo&#039;, &#039;bar&#039;);
    my $iter = Template::Iterator-&gt;new($list);

This is then functionally equivalent to:

    my $iter = Template::Iterator-&gt;new([ $list ]);

The iterator will return only one item, a reference to the C&lt;MyListObject&gt;
object, C&lt;$list&gt;.

By adding an C&lt;as_list()&gt; method to the C&lt;MyListObject&gt; class, we can force
the C&lt;Template::Iterator&gt; constructor to treat the object as a list and
use the data contained within.

    package MyListObject;

    ...

    sub as_list {
        my $self = shift;
        return $self;
    }

    package main;

    my $list = MyListObject-&gt;new(&#039;foo&#039;, &#039;bar&#039;);
    my $iter = Template::Iterator-&gt;new($list);

The iterator will now return the two items, &#039;C&lt;foo&gt;&#039; and &#039;C&lt;bar&gt;&#039;, which the
C&lt;MyObjectList&gt; encapsulates.

=head2 get_first()

Returns a C&lt;($value, $error)&gt; pair for the first item in the iterator set.
The C&lt;$error&gt; returned may be zero or undefined to indicate a valid datum
was successfully returned.  Returns an error of C&lt;STATUS_DONE&gt; if the list
is empty.

=head2 get_next()

Returns a C&lt;($value, $error)&gt; pair for the next item in the iterator set.
Returns an error of C&lt;STATUS_DONE&gt; if all items in the list have been
visited.

=head2 get_all()

Returns a C&lt;(\@values, $error)&gt; pair for all remaining items in the iterator
set.  Returns an error of C&lt;STATUS_DONE&gt; if all items in the list have been
visited.

=head2 size()

Returns the size of the data set or undef if unknown.

=head2 max()

Returns the maximum index number (i.e. the index of the last element)
which is equivalent to L&lt;size()&gt; - C&lt;1&gt;.

=head2 index()

Returns the current index number which is in the range C&lt;0&gt; to L&lt;max()&gt;.

=head2 count()

Returns the current iteration count in the range C&lt;1&gt; to L&lt;size()&gt;.  This is
equivalent to L&lt;index()&gt; + C&lt;1&gt;.

=head2 first()

Returns a boolean value to indicate if the iterator is currently on
the first iteration of the set.

=head2 last()

Returns a boolean value to indicate if the iterator is currently on
the last iteration of the set.

=head2 prev()

Returns the previous item in the data set, or C&lt;undef&gt; if the iterator is
on the first item.

=head2 next()

Returns the next item in the data set or C&lt;undef&gt; if the iterator is on the
last item.

=head2 number()

This is an alias to &#039;count&#039; to provide backward compatibility.
View L&lt;count&gt;.

=head2 parity()

Returns the text string C&lt;even&gt; or C&lt;odd&gt; to indicate the parity of the
current iteration count (starting at 1).  This is typically used to create
striped I&lt;zebra tables&gt;.

    &lt;table&gt;
    [% FOREACH name IN [&#039;Arthur&#039;, &#039;Ford&#039;, &#039;Trillian&#039;] -%]
      &lt;tr class=&quot;[% loop.parity %]&quot;&gt;
        &lt;td&gt;[% name %]&lt;/td&gt;
      &lt;/tr&gt;
    [% END %]
    &lt;/table&gt;

This will produce the following output:

    &lt;table&gt;
      &lt;tr class=&quot;odd&quot;&gt;
        &lt;td&gt;Arthur&lt;/td&gt;
      &lt;/tr&gt;
      &lt;tr class=&quot;even&quot;&gt;
        &lt;td&gt;Ford&lt;/td&gt;
      &lt;/tr&gt;
      &lt;tr class=&quot;odd&quot;&gt;
        &lt;td&gt;Trillian&lt;/td&gt;
      &lt;/tr&gt;
    &lt;/table&gt;

You can then style the C&lt;tr.odd&gt; and C&lt;tr.even&gt; elements using CSS:

    tr.odd td {
        background-color: black;
        color: white;
    }

    tr.even td {
        background-color: white;
        color: black;
    }

=head2 odd()

Returns a boolean (0/1) value to indicate if the current iterator count
(starting at 1) is an odd number. In other words, this will return a true
value for the first iterator, the third, fifth, and so on.

=head2 even()

Returns a boolean (0/1) value to indicate if the current iterator count
(starting at 1) is an even number. In other words, this will return a true
value for the second iteration, the fourth, sixth, and so on.

=head1 AUTHOR

Andy Wardley E&lt;lt&gt;abw@wardley.orgE&lt;gt&gt; L&lt;http://wardley.org/&gt;

=head1 COPYRIGHT

Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L&lt;Template&gt;

=cut

# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/local/lib64/perl5/Template/Iterator.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flocal%2Flib64%2Fperl5%2FTemplate' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>