Class::Composite::Container - Collection of Class::Composite::Element

  use Class::Composite::Container;
  my $c = Class::Composite::Container->new();
  $c->nextElement();
  $c->resetPointer();
  $c->nextElement();
  $obj = $c->getElement();
  $list = $c->getElements(2, 5);

  while ( my $elem = $container->nextElement ) { ... }

package Class::Composite::Container;

use strict;
use warnings::register;
use Scalar::Util qw ( blessed );

use base  qw( Class::Composite );

our $VERSION = 0.1;

sub init : method {
  my $self = shift;
  $self->SUPER::init( @_ );
  $self->{elements}    ||= [];
  $self->{elempointer} ||= 0;
  $self;
}

sub elements : method {
  my $self = shift;
  my $elem = shift or return $self->{elements};
  ref $elem eq 'ARRAY' or return $self->_warn("Not an array ref: $elem");
  $self->{elements} = $elem;
  $self;
}

sub elempointer : method {
  my ($self, $elem) = @_;
  defined $elem or return $self->{elempointer};
  $elem = $self->nOfElements - 1 if $elem >= $self->nOfElements;
  $elem = 0 if $elem < 0;
  $self->{elempointer} = int $elem;
  $self;
}

sub addElement : method {
  my ($self, @args) = @_;

  foreach (@args) {
    $self->_addThis(this => $_) or return;
  }
  $self;
}

sub addElementFlat : method {
  my ($self, @args) = @_;
  foreach (@args) {
    $self->_addThis( this => $_,
                     flat => 1   ) or return;
  }
  $self;
}


#
# _addThis(this => $id or $object, flat => 0/1)
#
sub _addThis {
  my ($self, %args) = @_;
  my $object = $args{this};
  my $flat   = $args{flat} || 0;
  $self->checkElement( $object ) or return $self->_warn("Element to add is not of type ".$self->elementType);
  if ($flat and ref($object)) {
    my $objects = $object->isa('Class::Composite::Container') ? $object->getLeaves
                                                              : [ $object ];
    $self->_addTheseObj( $objects );
  }
  else {
    $self->_addTheseObj( [$object] );
  }
}


sub _addTheseObj {
  my ($self, $objects) = @_;
  push @{$self->{elements}}, @$objects;
}

sub checkElement {
  my ($self, $elem) = @_;
  my $type = $self->elementType or return 1;
  return 1 unless defined $elem;
  if (blessed($elem)) {
    return $elem->isa($type);
  }
  else {
    return ref($elem) eq $type;
  }
}

sub getElement {
  my ($self, $id) = @_;
  $id = $self->elempointer unless defined $id;

  return unless exists $self->{elements};

  if (defined( $self->{elements}->[$id] )) {
    return $self->{elements}->[$id];
  } else {
    return undef;
  }
}

sub getElements {
  my ($self, $start, $end) = @_;
  $start ||= 0;
  return [] unless $self->{elements};
  $end = @{$self->{elements}} - 1 unless defined $end;
  [ @{$self->{elements}}[$start .. $end] ];
}

sub removeElement {
  my ($self, $index) = @_;
  $index = $self->elempointer unless defined $index;
  splice @{ $self->{elements} }, $index, 1;
}

sub removeAll {
  my $self = shift;
  $self->{elements}    = [];
  $self->{elempointer} = 0;
  $self;
}

sub nOfElements {
  scalar(@{$_[0]->{elements}}) || 0;
}

sub nextElement {
  my $self = shift;
  $self->getElement( $self->incrPointer() );
}

sub previousElement {
  my $self = shift;
  $self->decrPointer or do { $self->resetPointer(); return };
  $self->getElement();
}

sub incrPointer : method {
  $_[0]->{elempointer}++;
}

sub decrPointer : method {
  $_[0]->{elempointer}--;
}

sub resetPointer : method {
  my $self = shift;
  my $ret  = $self->{elempointer};
  $self->{elempointer} = shift || 0;
  $ret;
}

sub setPointer : method {
  my ($self, $i) = @_;
  my $current = $self->{elempointer};
  $i = $self->nOfElements - 1 if ($i >= $self->nOfElements);
  $i = 0                      if ($i < 0);
  $self->{elempointer} = $i;
  $current;
}



1;

__END__