Net::LDAP::Class::Iterator - iterate over Net::LDAP::Class objects

 my $iterator = $user->groups_iterator;
 while ( my $group = $iterator->next ) {
    # $group isa Net::LDAP::Class::Group
 }
 printf("%d groups found\n", $iterator->count);

 my $group = MyADGroup->new( cn => 'myBigGroup', ldap => $ldap )->read;
 my $users = $group->users;  # bitten by AD! returns an empty array ref!
 foreach my $user (@$users) {
   # nothing here -- the array is empty
 }

 my $users = $group->users_iterator;
 while ( my $user = $users->next ) {
    # do something with $user
 }
 printf("We saw %d users in group %s\n", $users->count, $group->name);

 my $users = $group->users_iterator;
 my @allusers;
 while ( my $user = $users->next ) {
     push @allusers, $user;
 }

    perldoc Net::LDAP::Class

package Net::LDAP::Class::Iterator;
use strict;
use warnings;
use base qw( Rose::Object );
use Carp;
use Data::Dump qw( dump );
use Net::LDAP::Class::MethodMaker (
    'scalar' => [qw( ldap base_dn page_size filter class )], );
use Net::LDAP::Control::Paged;
use Net::LDAP::Constant qw( LDAP_CONTROL_PAGED );

our $VERSION = '0.26';

sub init {
    my $self = shift;
    $self->SUPER::init(@_);
    if ( !$self->class ) {
        croak "class param required";
    }
    my $page_size = $self->page_size || 500;
    $self->{_page}   = Net::LDAP::Control::Paged->new( size => $page_size, );
    $self->{_count}  = 0;
    $self->{_cookie} = undef;
    $self->_do_search();
    return $self;
}

sub _cookie_check {
    my $self = shift;
    my ($resp) = $self->{_ldap_search}->control(LDAP_CONTROL_PAGED)
        or croak "failed to get PAGED control response";

    $self->{_cookie} = $resp->cookie;
    if ( !$self->{_cookie} ) {
        return;
    }

    # Set cookie in paged control
    $self->{_page}->cookie( $self->{_cookie} );

    return $self->{_cookie};
}

sub _do_search {
    my $self = shift;

    # execute the search, stashing the search object
    my $filter = $self->filter or croak "filter required";
    my $base_dn    = $self->base_dn || $self->class->metadata->base_dn;
    my $attributes = $self->class->metadata->attributes;
    my @args       = (
        'base'    => $base_dn,
        'filter'  => $filter,
        'attrs'   => $attributes,
        'control' => [ $self->{_page} ],
    );
    my $ldap = $self->ldap or croak "need Net::LDAP object";

    #warn "$self->{_count} : _do_search with args: " . dump( \@args ) . "\n";

    my $ldap_search = $ldap->search(@args);

    if ( !$ldap_search ) {

        # be nice to the server and stop the search
        # if we still have a cookie
        if ( $self->{_cookie} ) {
            $self->{_page}->size(0);
            $self->{_page}->cookie( $self->{_cookie} );
            $ldap->search(@args);
            croak "LDAP seach ended prematurely.";
        }

        $self->{_exhausted} = 1;
        return;    # no more entries

    }

    # fatal on search error
    croak "error searching ldap: ",
        Net::LDAP::Class->get_ldap_error($ldap_search)
        if ( $ldap_search->code );

    $self->{_current_set} = $ldap_search->count;
    $self->{_ldap_search} = $ldap_search;

    # if we found nothing.
    if ( !$self->{_current_set} ) {
        $self->{_exhausted} = 1;
        return;
    }

    return $self;
}

sub count {
    return shift->{_count};
}

sub is_exhausted {
    return shift->{_exhausted};
}

sub next {
    my $self = shift;

    return undef if $self->{_exhausted};

    my $ldap_entry = $self->{_ldap_search}->shift_entry;

    if ( !defined $ldap_entry ) {

        #warn "no ldap_entry ... trying next page";

        # handle next search page
        $self->_cookie_check;

        # if there is no cookie, this was the last page.
        if ( !$self->{_cookie} ) {
            $self->{_exhausted} = 1;
            return undef;
        }

        $self->_do_search or return undef;
        $ldap_entry = $self->{_ldap_search}->shift_entry;
        if ( !$ldap_entry ) {
            $self->{_exhausted} = 1;
            return undef;
        }
    }

    $self->{_count}++;

    return $self->class->new(
        ldap       => $self->ldap,
        ldap_entry => $ldap_entry
    );

}

sub finish {
    my $self = shift;
    $self->{_page}->size(0);
    $self->_cookie_check;
    if ( !$self->_do_search() ) {
        return 1;
    }
    else {
        return 0;
    }
}

sub DESTROY {
    my $self = shift;
    if ( !$self->is_exhausted ) {
        carp("non-exhausted iterator DESTROY'd");
        Data::Dump::dump($self);
        $self->finish();
    }
}

1;

__END__