use Bio::PopGen::IO;
  my $io = new Bio::PopGen::IO(-format => 'csv',
                               -file   => 'data.csv');

  # Some IO might support reading in a population at a time

  my @population;
  while( my $ind = $io->next_individual ) {
      push @population, $ind;
  }

    my($self, @args) = @_;
    my ($fieldsep,$all_sep, 
	$noheader) = $self->_rearrange([qw(FIELD_DELIMITER
					   ALLELE_DELIMITER
					   NO_HEADER)],@args);


    $self->flag('no_header', defined $noheader ? $noheader : $NoHeader);
    $self->flag('field_delimiter',defined $fieldsep ? $fieldsep : $FieldDelim);
    $self->flag('allele_delimiter',defined $all_sep ? $all_sep : $AlleleDelim);

    $self->{'_header'} = undef;
    return 1;

    my $self = shift;
    my $fieldname = shift;
    return unless defined $fieldname;
    
    return $self->{'_flag'}->{$fieldname} = shift if @_;
    return $self->{'_flag'}->{$fieldname};

    my ($self) = @_;
    while( defined( $_ = $self->_readline) ) {
	next if( /^\s*\#/ || /^\s+$/ || ! length($_) );
	last;
    }
    return if ! defined $_; 
    if( $self->flag('no_header') || 
	defined $self->{'_header'} ) {

	#########new (allows field delim to be the same as the allele delim

	my ($samp,@marker_results);

	if($self->flag('field_delimiter') ne $self->flag('allele_delimiter')){

		($samp,@marker_results) = split($self->flag('field_delimiter'),$_);
	}
	else{

		my $fielddelim = $self->flag('field_delimiter');
		my $alleledelim = $self->flag('allele_delimiter');

		($samp) = /(^.+?)$fielddelim/;
		s/^.+?$fielddelim//;
	
		(@marker_results) = /([\d|\w]+$alleledelim[\d|\w]+)/g;
	
	}

	#########end new

	my $i = 1;
	foreach my $m ( @marker_results ) {
	    $m =~ s/^\s+//;
	    $m =~ s/\s+$//;
	    my $markername;
	    if( defined $self->{'_header'} ) {
		$markername = $self->{'_header'}->[$i];
	    } else { 
		$markername = "Marker$i";
	    }
	    $self->debug( "markername is $markername alleles are $m\n");

	    my @alleles = split($self->flag('allele_delimiter'), $m);
		
	    $m = new Bio::PopGen::Genotype(-alleles      =>\@ alleles,
					   -marker_name  => $markername,
					   -individual_id=> $samp); 
	    $i++; 
	}
	return new Bio::PopGen::Individual(-unique_id => $samp,
					   -genotypes =>\@ marker_results);
    } else {
	chomp;
	$self->{'_header'} = [split($self->flag('field_delimiter'),$_)];
	return $self->next_individual; # rerun loop again
    }
    return;

    my ($self) = @_;
    my @inds;
    while( my $ind = $self->next_individual ) {
	push @inds, $ind;
    }
    Bio::PopGen::Population->new(-individuals =>\@ inds);

    my ($self,@inds) = @_;
    my $fielddelim  = $self->flag('field_delimiter');
    my $alleledelim= $self->flag('allele_delimiter');
    
    foreach my $ind ( @inds ) {
	if (! ref($ind) || ! $ind->isa('Bio::PopGen::IndividualI') ) {
	    $self->warn("Cannot write an object that is not a Bio::PopGen::IndividualI object ($ind)");
	    next;
	}
	# we'll go ahead and sort these until
	# we have a better way to insure a consistent order
	my @marker_names = sort $ind->get_marker_names;
	if( ! $self->flag('no_header') && 
	    ! $self->flag('header_written') ) {
	    $self->_print(join($fielddelim, ('SAMPLE', @marker_names)), "\n");
	    $self->flag('header_written',1);
	}
	$self->_print( join($fielddelim, $ind->unique_id, 
			    # we're chaining map here, pay attention and read
			    # starting with the last map
			    
			    # we'll turn genotypes into allele pairs
			    # which will be separated by the allele delimiter
			    map { join($alleledelim,$_->get_Alleles) } 
			    # marker names will be sorted so we don't
			    # have to worry about this between individuals
			    # unless the individual set you pass in has 
			    # a mixed set of markers...
			    # this will turn marker names into Genotypes
			    map {$ind->get_Genotypes(-marker => $_)} 
			    @marker_names), "\n")
    }

    my ($self,@pops) = @_;
    my $fielddelim  = $self->flag('field_delimiter');
#     my $alleledelim= $self->flag('allele_delimiter');
    my $alleledelim = ' ';
    foreach my $pop ( @pops ) {
	if (! ref($pop) || ! $pop->isa('Bio::PopGen::PopulationI') ) {
	    $self->warn("Cannot write an object that is not a Bio::PopGen::PopulationI object");
	    next;
	}
	# we'll go ahead and sort these until
	# we have a better way to insure a consistent order
	my @marker_names = sort $pop->get_marker_names;
	if( ! $self->flag('no_header') && 
	    ! $self->flag('header_written') ) {
	    $self->_print( join($fielddelim, ('SAMPLE', @marker_names)), 
			   "\n");
	    $self->flag('header_written',1);
	}
	foreach my $ind ( $pop->get_Individuals ) {
	   $self->_print( join($fielddelim, $ind->unique_id, 
			       # we're chaining map here, pay attention 
			       # and read starting with the last map
			       
			       # we'll turn genotypes into allele pairs
			       # which will be separated by the allele 
			       # delimiter
			       map { join($alleledelim,$_->get_Alleles) } 
			       # marker names will be sorted so we don't
			       # have to worry about this between individuals
			       # unless the individual set you pass in has 
			       # a mixed set of markers...
			       # this will turn marker names into Genotypes
			       map {$ind->get_Genotypes(-marker => $_)} 
			       @marker_names), "\n");
       }    
    }

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

  http://bugzilla.open-bio.org/

 Title   : new
 Usage   : my $obj = new Bio::PopGen::IO::csv();
 Function: Builds a new Bio::PopGen::IO::csv object 
 Returns : an instance of Bio::PopGen::IO::csv
 Args    : [optional, these are the current defaults] 
           -field_delimiter => ','
           -allele_delimiter=> '\s+'
           -no_header       => 0,