# a report for sequencing stuff
  my $o_consed = new Bio::Tools::Alignment::Consed( 
      -acefile => "/path/to/an/acefile.ace.1",
      -verbose => 1);
  my $foo = $o_consed->set_reverse_designator("r");
  my $bar = $o_consed->set_forward_designator("f");

  # get the contig numbers
  my @keys = $o_consed->get_contigs();

  # construct the doublets
  my $setter_doublets = $o_consed->choose_doublets();

  # get the doublets
  my @doublets = $o_consed->get_doublets();

    %DEFAULTS = ( 'f_designator' => 'f',
		  'r_designator' => 'r');

	my ($self,$r_array) = @_;
	my @contig_members = @$r_array;
	my @name_nodir;
	foreach (@contig_members) {
			# how can I distinguish the clone name from the direction label?
			# look for $Consed::reverse_designator and $Consed::forward_designator
			# what if you do not find _any_ of those?
		my $forward_designator = $self->{'forward_designator'} || "f";
		my $reverse_designator = $self->{'reverse_designator'} || "r";
		my $any_hits = /(.+)($forward_designator.*)/ || /(.+)($reverse_designator.*)/||/(.+)(_.+)/;
		my $name = $1;
		my $suffix = $2;
		if ($name) {
			# print("\t\$name is $name ");
		}
		if ($suffix) {
			# print("and \$suffix is $suffix.\n");
		}
                                # Jee, I hope we get a naming convention soon
		if ($suffix) {
			if ($suffix =~ /^$forward_designator/ || $suffix =~ /^$reverse_designator/) {
				push @name_nodir,$name;
			}
				# bugwatch here! should this be unnested?
			else {
				push @name_nodir,"$name$suffix";
			}
		}
	}
		# print("\@name_nodir: @name_nodir\n");
	my $mismatch = 0;
	for (my $counter=0; $counter<@name_nodir;$counter++) {
		next if ($name_nodir[0] eq $name_nodir[$counter]);
		$mismatch = 1;
	}
	if ($mismatch == 0) {
			# print("\tYou have a cohesive contig named $name_nodir[0].\n\n");
		return $name_nodir[0];
	}
	else {
			# print("\tYou have mixed names in this contig.\n\n");
	}
} # end _get_contig_name

    my ($self) = @_;
    my ($line,$in_contig,$in_quality,$contig_number,$top); 
    # make it easier to type $fhl
    while (defined($line=$self->_readline()) ) {
	chomp $line;
	# check if there is anything on this line
	# if not, you can stop gathering consensus sequence
	if (!$line) {
	    # if the line is blank you are no longer to gather consensus 
	    # sequence or quality values
	    $in_contig = 0;
	    $in_quality = 0;
	}
	# you are currently gathering consensus sequence
	elsif ($in_contig) {
	    if ($in_contig == 1) {
		$self->debug("Adding $line to consensus of contig number $contig_number.\n");
		$self->{'contigs'}->{$contig_number}->{'consensus'} .= $line;
	    }
	}
	elsif ($in_quality) {
	    if (!$line) {
		$in_quality = undef;
	    }
	    else {
		# I wrote this in here because acefiles produced by cap3 do not have a leading space
		# like the acefiles produced by phrap and there is the potential to have concatenated
		# quality values like this: 2020 rather then 20 20 whre lines collide. Thanks Andrew for noticing.
		if ($self->{'contigs'}->{$contig_number}->{'quality'} && !($self->{'contigs'}->{$contig_number}->{'quality'} =~ m/\ $/)) {
		    $self->{'contigs'}->{$contig_number}->{'quality'} .= " ";
		}
		$self->{'contigs'}->{$contig_number}->{'quality'} .= $line;
	    }
	}
	elsif ($line =~ /^BQ/) {
	    $in_quality = 1;
	}
	# the line /^CO/ like this:
	# CO Contig1 796 1 1 U
	# can be broken down as follows:
	# CO - Contig!
	# Contig1 - the name of this contig
	# 796 - Number of bases in this contig
	# 1 - Number of reads in this contig
	# 1 - number of base segments in this contig
	# U - Uncomplemented
	elsif ($line =~ /^CO/) {
	    $line =~ m/^CO\ Contig(\d+)\ \d+\ \d+\ \d+\ (\w)/;
	    $contig_number = $1;
	    if ($2 eq "C") {
		$self->debug("Contig $contig_number is complemented!\n");
	    }
	    $self->{'contigs'}->{$contig_number}->{'member_array'} = [];
	    $self->{'contigs'}->{$contig_number}->{'contig_direction'} = "$2";
	    $in_contig = 1;
	}
	# 000713
	# this BS is deprecated, I think.
	# haha, I am really witty. <ew>
	elsif ($line =~ /^BSDEPRECATED/) {
	    $line =~ m/^BS\s+\d+\s+\d+\s+(.+)/;
	    my $member = $1;
	    $self->{'contigs'}->{$contig_number}->{$member}++;
	}
	# the members of the contigs are determined by the AF line in the ace file
	elsif ($line =~ /^AF/) {
	    $self->debug("I see an AF line here.\n");
	    $line =~ /^AF\ (\S+)\ (\w)\ (\S+)/;
				# push the name of the current read onto the member array for this contig
	    push @{$self->{'contigs'}->{$contig_number}->{'member_array'}},$1;
				# the first read in the contig will be named the "top" read				
	    if (!$top) {
		$self->debug("\$top is not set.\n");
		if ($self->{'contigs'}->{$contig_number}->{'contig_direction'} eq "C") {
		    $self->debug("Reversing the order of the reads. The bottom will be $1\n");
		    # if the contig sequence is marked as the complement, the top becomes the bottom and$
		    $self->{'contigs'}->{$contig_number}->{'bottom_name'} = $1;
		    $self->{'contigs'}->{$contig_number}->{'bottom_complement'} = $2;
		    $self->{'contigs'}->{$contig_number}->{'bottom_start'} = $3;
		}
		else {
		    $self->debug("NOT reversing the order of the reads. The top_name will be $1\n");
		    # if the contig sequence is marked as the complement, the top becomes the bottom and$
		    $self->{'contigs'}->{$contig_number}->{'top_name'} = $1;
		    $self->{'contigs'}->{$contig_number}->{'top_complement'} = $2;
		    $self->{'contigs'}->{$contig_number}->{'top_start'} = $3;
		}
		$top = 1;
	    }
	    else {
		# if the contig sequence is marked as the complement, the top becomes the bottom and the bottom becomes the top
		if ($self->{'contigs'}->{$contig_number}->{'contig_direction'} eq "C") {
		    $self->debug("Reversing the order of the reads. The top will be $1\n");
		    $self->{'contigs'}->{$contig_number}->{'top_name'} = $1;
		    $self->{'contigs'}->{$contig_number}->{'top_complement'} = $2;
		    $self->{'contigs'}->{$contig_number}->{'top_start'} = $3;
		}
		else {
		    $self->debug("NOT reversing the order of the reads. The bottom will be $1\n");
		    $self->{'contigs'}->{$contig_number}->{'bottom_name'} = $1;
		    $self->{'contigs'}->{$contig_number}->{'bottom_complement'} = $2;
		    $self->{'contigs'}->{$contig_number}->{'bottom_start'} = $3;
		}
		$top = undef;
	    }
	}
    }
    return 0;

    my $self = shift;
    my ($working_dir,$grep_cli,@total_grep_sequences);
    # this should be migrated to a pure perl implementation ala
    # Tom Christiansen's 'tcgrep'
    # http://www.perl.com/language/ppt/src/grep/tcgrep

    open(FILE, $self->{'filename'}) or do { $self->warn("cannot open file ".$self->{'filename'}. " for grepping"); return}; 
    my $counter =0;
    while(<FILE>) { $counter++ if(/^AF/); }

    close FILE;
    opendir(SINGLETS,$self->{'path'});
    foreach my $f ( readdir(SINGLETS) ) {
	next unless ($f =~ /\.singlets$/); 
	open(FILE, $self->catfile($self->{'path'},$f)) or do{ $self->warn("cannot open file ".$self->catfile($self->{'path'},$f)); next };
	while(<FILE>) { $counter++ if(/^>/) }
	close FILE;
    }
    return $counter;
# Chad's platform implementation which required grep on the system

    # I tried to cause graceful exiting if not on *ix here
    # then i took platforms from Bioperl*/PLATFORMS here. Is that good?
    # print("\$^O is $^O\n");
#	if (!($^O =~ /dec_osf|linux|unix|bsd|solaris|darwin/i)) {
#	$self->warn("Bio::Tools::Alignment::Consed::count_sequences_with_grep: This sub uses grep which is doesn't run on this operating system, AFAIK. Sorry   .".$^O);
#	return 1;
#    }
#    $grep_cli = `which grep`;
#    if (!$grep_cli) {
#	$self->warn("I couldn't see to find grep on this system, or the which command is broken. Bio::Tools::Alignment::Consed::count_sequences_with_grep requires grep and which to find grep.");
#	return 1;
#    }
#    chomp $grep_cli;
#    push(@total_grep_sequences, my @foo = `$grep_cli ^AF $self->{filename}`);
#    my $cli = "$grep_cli \\> $self->{'path'}*.singlets";
#    push(@total_grep_sequences, @foo = `$cli`);
#    return scalar(@total_grep_sequences);

	my $self = shift;
	my $dumper = new Dumpvalue;
	$self->debug( "Bio::Tools::Alignment::Consed::dump_hash - ".
		      "The following is the contents of the contig hash...\n");
	$dumper->dumpValue($self->{'contigs'});

	no strict 'refs';  # renege for the block
	my ($self,$sequence) = @_;
		# get the classes
	my @singlets = $self->get_singlets();
	my @singletons = $self->get_singletons();
	my @doublets = $self->get_doublets();
	my @pairs = $self->get_pairs();
	my @multiplets = $self->get_multiplets();
	print("Name\tClass\tMembers\tQuality?\n");
	foreach (@singlets) {
		my @members = $self->get_members($_);
		print($self->get_name($_)."\tsinglets\t".(join',',@members)."\t");
		if ($self->{'contigs'}->{$_}->{'quality'}) { print("qualities found here\n"); }
		else { print("no qualities found here\n"); }

	}
	foreach (@singletons) {
		my @members = $self->get_members($_);
		print($self->get_name($_)."\tsingletons\t".(join',',@members)."\t");
		if ($self->{'contigs'}->{$_}->{'quality'}) { print("qualities found here\n"); }
		else { print("no qualities found here\n"); }
	}
	foreach my $pair (@pairs) {
		my @members = $self->get_members($pair);
		my $name;
		if (!$self->get_name($pair)) {
			$name = "BLANK";
		}
		else { $name = $self->get_name($pair); }
		print("$name\tpairs\t".(join',',@members)."\n");
	}
	foreach (@doublets) {
		my @members = $self->get_members_by_name($_);
		print("$_\tdoublets\t".(join',',@members)."\t");
		my $contig_number = &get_contig_number_by_name($self,$_);
		if ($self->{'contigs'}->{$contig_number}->{'quality'}) { print("qualities found here\n"); }
		else { print("no qualities found here\n"); }
		# print($_."\tdoublets\t".(join',',@members)."\n");
	}
	foreach (@multiplets) {
		my @members = $self->get_members($_);
		print("Contig $_"."\tmultiplets\t".(join',',@members)."\n");
	}
} # end dump_hash_compact

    my $self = shift;
	$self->warn("This method (freeze_hash) was removed from the bioperl consed.pm. Sorry.\n");
	if (1==2) {
	    $self->debug("Bio::Tools::Alignment::Consed::freeze_hash:\$ self->{path} is $self->{path}\n");
	    my $filename = $self->{'path'}."frozen";
	    my %contigs = %{$self->{'contigs'}};
	    my $frozen = freeze(%contigs);
	    umask 0001;
	    open (FREEZE,">$filename") or do {
		$self->warn( "Bio::Tools::Alignment::Consed could not freeze the contig hash because the file ($filename) could not be opened: $!\n");
		return 1;
	    };
	    print FREEZE $frozen;
	    close FREEZE;
	    return 0;
	}

    my $self = shift;
    my @members;
    foreach my $key (sort keys %{$self->{'contigs'}}) {
	if ($key =~ /^singlet/) {
	    push @members,$self->{'contigs'}->{$key}->{'member_array'}[0];
	}
	elsif ($self->{'contigs'}->{$key}->{'member_array'}) {
	    push @members,@{$self->{'contigs'}->{$key}->{'member_array'}};
	}
	# else {
	#	print("Bio::Tools::Alignment::Consed: $key is _not_ an array. Pushing $self->{'contigs'}->{$key}->{'member_array'} onto \@members\n");
	#	push @members,$self->{'contigs'}->{$key}->{'member_array'};
	# }
    }
    return @members;

    my ($self,$contig) = @_;
    return $self->{contigs}->{$contig}->{class};

    my ($self,$name) = @_;
    foreach my $currkey (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'}->{$currkey}->{'name'} && 
	    $self->{'contigs'}->{$currkey}->{'name'} eq "$name") {
	    return $currkey;
	}
    }

    my ($self,$contig) = @_;
    my @keys = (sort keys %{$self->{'contigs'}});
    return @keys;

	my $self = shift;
	if (!$self->{doublets_set}) {
		$self->warn("You need to set the doublets before you can get them. Doing that now.");
		$self->set_doublets();
	}
	my @doublets;
	foreach (sort keys %{$self->{'contigs'}}) {
	    if ($self->{'contigs'}->{$_}->{name} && $self->{'contigs'}->{$_}->{'class'} eq "doublet") {
		push @doublets,$_;
	    }
	}
	return @doublets;
} # end get_doublets

    my $self = shift;
    return $self->{'filename'};

    my ($self,$contig) = @_;
    if (!$contig) {
	$self->warn("You need to provide the name of a contig to use Bio::Tools::Alignment::Consed::get_members!\n");
	return;
    }
    return @{$self->{'contigs'}->{$contig}->{'member_array'}};

    my ($self,$name) = @_;
	    # build a list to try to screen for redundancy
    my @contigs_with_that_name;
    foreach my $currkey ( sort keys %{$self->{'contigs'}} ) {
	next if (!$self->{'contigs'}->{$currkey}->{'name'});
	if ($self->{'contigs'}->{$currkey}->{'name'} eq "$name") {
	    push @contigs_with_that_name,$currkey;
	}
    }
    my $count = @contigs_with_that_name;
    if ($count == 1) {
	my $contig_num = $contigs_with_that_name[0];
	return @{$self->{'contigs'}->{$contig_num}->{'member_array'}};
    }

	    # returns an array of multiplet names
	    # multiplets have # members > 2
    my $self = shift;
    my (@multiplets,@array);
    foreach my $key (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'}->{$key}->{'class'}) {
	    if ($self->{'contigs'}->{$key}->{'class'} eq "multiplet") {
		push @multiplets,$key;
	    }
	}
    }
    return @multiplets;

	my ($self,$contig) = @_;
	return $self->{'contigs'}->{$contig}->{'name'};

		# returns an array of pair contig names
		# a pair is a contig of two where the names do not match
	my $self = shift;
	my (@pairs,@array);
	foreach my $key (sort keys %{$self->{'contigs'}}) {
		if ($self->{'contigs'}->{$key}->{'member_array'}) {
			if (@{$self->{'contigs'}->{$key}->{'member_array'}} == 2 && 
			    $self->{'contigs'}->{$key}->{'class'} eq "pair") {
				push @pairs,$key;
			}
		}
	}
	return @pairs;

	my $self = shift;
	return $self->{'path'};

    # this subroutine is the target of a rewrite to use the Bio::Tools::Alignment::Phred object.
    my $self = shift;    
    my $current_contig;
    foreach $current_contig (sort keys %{$self->{'contigs'}}) {	
	if ($self->{'contigs'}->{$current_contig}->{'class'} eq "doublet") {
	    $self->debug("$current_contig is a doublet. Going to parse_phd for top($self->{'contigs'}->{$current_contig}->{'top_name'}) and bottom($self->{'contigs'}->{$current_contig}->{'bottom_name'})\n");
	    my $r_phreds_top = &parse_phd($self,$self->{'contigs'}->{$current_contig}->{'top_name'});
	    my $r_phreds_bottom = &parse_phd($self,$self->{'contigs'}->{$current_contig}->{'bottom_name'});
	    if ($self->{'contigs'}->{$current_contig}->{'top_complement'} eq "C") {
		# print("Reversing and complementing...\n");
		$r_phreds_top = &reverse_and_complement($r_phreds_top);
	    }
	    if ($self->{'contigs'}->{$current_contig}->{'bottom_complement'} eq "C") {
		$r_phreds_bottom = &reverse_and_complement($r_phreds_bottom);
	    }
	    $self->{'contigs'}->{$current_contig}->{'top_phreds'} = $r_phreds_top;
	    $self->{'contigs'}->{$current_contig}->{'bottom_phreds'} = $r_phreds_bottom;
	}
    }

    my ($self,$contig) = @_;
     my $quality =  $self->{contigs}->{$contig}->{quality};
          # chad, what is with the s/// ?
          # my @qualities = split
	     # (' ',($self->{contigs}->{$contig}->{quality} =~ s/\s+//));
      my @qualities = split
	     (' ',$self->{contigs}->{$contig}->{quality});
    return @qualities;

    my ($self,$contig) = @_;
    return $self->{'contigs'}->{$contig}->{'quality'};

    my ($self,$contig) = @_;
    return $self->{'contigs'}->{$contig}->{'consensus'};

		# returns an array of singleton names
		# singletons are contigs with one member (see consed documentation)
	my $self = shift;
	my (@singletons,@array);
	foreach my $key (sort keys %{$self->{'contigs'}}) {
		if ($self->{'contigs'}->{$key}->{'class'}) {
		    # print ("$key class: $self->{'contigs'}->{$key}->{'class'}\n");
		}
		else {
		    # print("$key belongs to no class. why?\n");
		}
		if ($self->{'contigs'}->{$key}->{'member_array'}) {
			@array = @{$self->{'contigs'}->{$key}->{'member_array'}};
		}
		my $num_array_elem = @array;
		if ($num_array_elem == 1 && $self->{'contigs'}->{$key}->{'class'} && $self->{'contigs'}->{$key}->{'class'} eq "singleton") { push @singletons,$key; }
	}
	return @singletons;

    # returns an array of singlet names
    # singlets have "singlet"=1 in the hash
    my $self = shift;
    if (!$self->{singlets_set}) {
	$self->debug("You need to set the singlets before you get them. Doing that now.");
	$self->set_singlets();
    }	

    my (@singlets,@array);
    foreach my $key (sort keys %{$self->{'contigs'}}) {
	# @array = @{$Consed::contigs{$key}->{'member_array'}};
	# somethimes a user will try to get a list of singlets before the classes for the rest of the
	# contigs has been set (see t/test.t for how I figured this out. <bah>			
	# so either way, just return class=singlets
	if (!$self->{'contigs'}->{$key}->{'class'}) {
	    # print("$key has no class. why?\n");
	}
	elsif ($self->{'contigs'}->{$key}->{'class'} eq "singlet") {
	    push @singlets,$key;
	}
    }
    return @singlets;

    my ($self,$name) = @_;
    my $trimmed_sequence;
    my $contigname = &get_contig_number_by_name($self,$name);
    my $class = $self->{'contigs'}->{$contigname}->{'class'};
    # what is this business and who was smoking crack while writing this?
    # if ($class eq "singlet") {
    # send the sequence, the quality, and the name
    # $trimmed_sequence = $self->{o_trim}->trim_singlet($self->{'contigs'}->{$contigname}->{consensus},$self->{'contigs'}->{$contigname}->{'quality'},$name);
    # }
    return $self->{'contigs'}->{$contigname}->{'sequence_trimmed'};

    my ($class,%args) = @_;
    my $self = $class->SUPER::new(%args);

    $self->{'filename'} = $args{'-acefile'};
	# this is special to UNIX and should probably use catfile
    if (!($self->{'filename'} =~ /\//)) { 
	$self->{'filename'} = "./".$self->{'filename'}; 
    } 
    $self->{'filename'} =~ m/(.*\/)(.*)ace.*$/;
    $self->{'path'} = $1;
    $self->_initialize_io('-file'=>$self->{'filename'});
    $self->{'o_trim'} = new Bio::Tools::Alignment::Trim(-verbose => $self->verbose());
    $self->set_forward_designator($DEFAULTS{'f_designator'});    
    $self->set_reverse_designator($DEFAULTS{'r_designator'});    

    $self->_read_file();
    return $self;

    my ($self,$sequence_name) = @_;
    $self->debug("Parsing phd for $sequence_name\n");
    my $in_dna = 0;
    my $base_number = 0;
    my (@bases,@current_line);
    # print("parse_phd: $sequence_name\n");
    my $fh = new Bio::Root::IO(-file=>"$self->{path}/../phd_dir/$sequence_name.phd.1");
    # open(PHD,"<$self->{path}/../phd_dir/$sequence_name.phd.1") or
    #    die "Couldn't open the phred for $sequence_name\n";
    while ($fh->_readline()) {
	# print("Reading a line from a phredfile!\n");
	chomp;
	if (/^BEGIN_DNA/) { $in_dna = 1; next}
	if (/^END_DNA/) { last; }
	if (!$in_dna) { next; }
	push(@bases,$_);
    }
    return\@ bases;

	my $r_source = shift;
	my $r_destination;
	$r_destination = &reverse_recurse($r_source,$r_destination);
	return $r_destination;

	(my $r_source,my $r_destination) = @_;
	if (!@$r_source) { return $r_destination; }
	$_=pop(@$r_source);
	(s/c/g/||s/g/c/||s/a/t/||s/t/a/);
	push(@$r_destination,$_);
	&reverse_recurse($r_source,$r_destination);

    # note: contigs _include_ singletons but _not_ singlets
    my ($self) = shift;
          # the unexpected results I am referring to here are a doubling of quality values.
          # the profanity I uttered on discovering this reminded me of the simpsons:
          # Ned Flanders: "That is the loudest profanity I have ever heard!"
     $self->warn("set_contig_quality is deprecated and will likely produce unexpected results");
    my $full_filename = $self->{'filename'};
    # Run_SRC3700_2000-08-01_73+74.fasta.screen.contigs.qual
    # from Consed.pm
    $full_filename =~ m/(.*\/)(.*)ace.*$/;
    my ($base_path,$filename) = ($1,"$2"."contigs.qual");
    my $singletsfile = $base_path.$filename;
    if (-f $singletsfile) {
	# print("$singletsfile is indeed a file. Trying to open it...\n");
    }
    else {
	$self->warn("Bio::Tools::Alignment::Consed::set_contig_quality $singletsfile is not a file. Sorry.\n");
	return;
    }
    my $contig_quality_fh = Bio::Root::IO->new(-file => $singletsfile);

    my ($sequence,$name,$count,$identity,$line,$quality);
    while ($line = $contig_quality_fh->_readline()) {
	chomp $line;
	if ($line =~ /^\>/) {
	    $quality = undef;
	    $line =~ m/\>.*Contig(\d+)\s/;
	    $identity = $1;
	}
	else {
	    if ($self->{'contigs'}->{$identity} ) {
		$self->{'contigs'}->{$identity}->{'quality'} .= " $line";
	    }
	}
    }
}				# end set_contig_quality

    my ($self,$dash_present) = @_;
    if ($dash_present eq "yes") {
	$self->{'dash_present_in_sequence_name'} = 1;
    }
    else {
	$self->{'dash_present_in_sequence_name'} = 0;
    }
    return $self->{'dash_present_in_sequence_name'};
}				# end set_dash_present_in_sequence_name

    my ($self,$ignore_case) = @_;
    if ($ignore_case eq "yes") {
	$self->{'designator_ignore_case'} = 1;
    }
    return $self->{'designator_ignore_case'};
}				# end set_designator_ignore_case

    my ($self) = @_;
    # set the designators in the Bio::Tools::Alignment::Trim object
    
    $self->{'o_trim'}->set_designators($self->{'reverse_designator'},
				       $self->{'forward_designator'});
    #
    foreach my $key_contig (sort keys %{$self->{'contigs'}}) {

	# if there is a member array (why would there not be? This should be a die()able offence
	# but for now I will leave it
	if ($self->{'contigs'}->{$key_contig}->{'member_array'}) {
	    # if there are two reads in this contig 
	    # i am pretty sure that this is wrong but i am keeping it for reference
	    # if (@{$self->{'contigs'}->{$key_contig}->{'member_array'}} == 2 || !$self->{'contigs'}->{$key_contig}->{'class'}) {
	    # <seconds later>
	    # <nod> WRONG. Was I on crack?
	    if (@{$self->{'contigs'}->{$key_contig}->{'member_array'}} == 2) {
		$self->{'contigs'}->{$key_contig}->{'num_members'} = 2;
		$self->debug("\tThere are 2 members! Looking for the contig name...\n");
		my $name = _get_contig_name($self,$self->{'contigs'}->{$key_contig}->{'member_array'});
		$self->debug("The name is $name\n") if defined $name;
		if ($name) {
		    $self->{'contigs'}->{$key_contig}->{'name'} = $name;
		    $self->{'contigs'}->{$key_contig}->{'class'} = "doublet";
		}
		else {
		    $self->debug("$key_contig is a pair.\n");
		    $self->{'contigs'}->{$key_contig}->{'class'} = "pair";
		}
	    }
				# this is all fair and good but what about singlets?
				# they have one reads in the member_array but certainly are not singletons
	    elsif (@{$self->{'contigs'}->{$key_contig}->{'member_array'}} == 1) {
		# set the name to be the name of the read
		$self->{'contigs'}->{$key_contig}->{name} = @{$self->{'contigs'}->{$key_contig}->{'member_array'}}[0];
		# set the number of members to be one
		$self->{'contigs'}->{$key_contig}->{num_members} = 1;
		# if this was a singlet, it would already belong to the class "singlet"
		# so leave it alone
		# if it is not a singlet, it is a singleton! lablel it appropriately
		unless ($self->{'contigs'}->{$key_contig}->{'class'}) {
		    $self->{'contigs'}->{$key_contig}->{'class'} = "singleton";
		}
	    }
				# set the multiplet characteristics
	    elsif (@{$self->{'contigs'}->{$key_contig}->{'member_array'}} >= 3) {
		$self->{'contigs'}->{$key_contig}->{'num_members'} = @{$self->{'contigs'}->{$key_contig}->{'member_array'}};
		$self->{'contigs'}->{$key_contig}->{'class'} = "multiplet";
	    }
	    $self->{'contigs'}->{$key_contig}->{'num_members'} = @{$self->{'contigs'}->{$key_contig}->{'member_array'}};

	}
    }
    $self->{'doublets_set'} = "done";
    return 0;
}				# end set_doublets

    my ($self,$name,$sequence) = @_;
    if (!$self->{'contigs'}->{$name}) {
	$self->warn("You cannot set the final sequence for $name because it doesn't exist!\n");
	return 1;
    }
    else {
	$self->{'contigs'}->{$name}->{'final_sequence'} = $sequence;
    }
    return 0;

    my ($self,$forward_designator) = @_;
    $self->{'forward_designator'} = $forward_designator;
    $self->{'o_trim'}->set_forward_designator($forward_designator);
    return $self->{'forward_designator'};
}				# end set_forward_designator

    # this is likely deprecated
    my ($self,$name,$quality) = shift;
    my $return;
    foreach (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'} eq "$name" || $self->{'contigs'}->{'name'} eq "$name") {
	    $self->{'contigs'}->{'quality'} = $quality;
	    $return=1;
	}
    }
    if ($return) { return "0"; } else { return "1"; }
}				# end set quality by name

    my ($self,$reverse_designator) = @_;
    $self->{'reverse_designator'} = $reverse_designator;
    $self->{'o_trim'}->set_reverse_designator($reverse_designator);
    return $self->{'reverse_designator'};
}				# end set_reverse_designator

    my $self = shift;
    my $full_filename = $self->{'filename'};
    $full_filename =~ m/(.*\/)(.*)ace.*$/;
    my ($base_path,$filename) = ($1,"$2"."qual");
    my $singletsfile = $base_path.$filename;
    if (-f $singletsfile) {
	# print("$singletsfile is indeed a file. Trying to open it...\n");
    }
    else {
	$self->warn("$singletsfile is not a file. Sorry.\n");
	return;
    }
	my $singlets_fh = Bio::Root::IO->new(-file => $singletsfile);
	my ($sequence,$name,$count);
    my ($identity,$line,$quality,@qline);
    while ($line = $singlets_fh->_readline()) {
	chomp $line;
	if ($line =~ /^\>/) {
	    $quality = undef;
	    $line =~ m/\>(\S*)\s/;
	    $identity = $1;
	}
	else {
	    if ($self->{'contigs'}->{$identity}) {
		$self->{'contigs'}->{$identity}->{'quality'} .= "$line ";
	    }
	}

    }
    return 0;

    # parse out the contents of the singlets file
    my ($self) = @_;
    $self->debug("Bio::Tools::Alignment::Consed Adding singlets to the contig hash...\n"); 
    my $full_filename = $self->{'filename'};
    $self->debug("Bio::Tools::Alignment::Consed::set_singlets:\$ full_filename is $full_filename\n");
    $full_filename =~ m/(.*\/)(.*ace.*)$/; 			       
    my ($base_path,$filename) = ($1,$2);
    $self->debug("Bio::Tools::Alignment::Consed::set_singlets: singlets filename is $filename and\$ base_path is $base_path\n");
    $filename =~ m/(.*)ace.*$/;
    my $singletsfile = $base_path.$1."singlets";
    $self->debug("\$singletsfile is $singletsfile\n");
    if (-f $singletsfile) {
	$self->debug("$singletsfile is indeed a file. Trying to open it...\n");
    }
    my $singlets_fh = Bio::Root::IO->new(-file => $singletsfile);
    my ($sequence,$name,$count);
    while ($_ = $singlets_fh->_readline()) {
	chomp $_;
	if (/\>/) {
	    if ($name && $sequence) {
		$self->debug("Adding $name with sequence $sequence to hash...\n");
		push @{$self->{'contigs'}->{$name}->{'member_array'}},$name;
		$self->{'contigs'}->{$name}->{'consensus'} = $sequence;
		$self->{'contigs'}->{$name}->{'name'} = $name;
		$self->{'contigs'}->{$name}->{"singlet"} = 1;
		$self->{'contigs'}->{$name}->{'class'} = "singlet";
	    }
	    $sequence = $name = undef;
	    $count++;
	    m/^\>(.*)\s\sCHROMAT/;
	    $name = $1;
	    if (!$name) {
		m/\>(\S+)\s/;
		$name = $1;
	    }
	}
	else { $sequence .= $_; }	
    }
    if ($name && $sequence) {
	$self->debug("Pushing the last of the singlets ($name)\n");
	@{$self->{'contigs'}->{$name}->{'member_array'}} = $name;
	$self->{'contigs'}->{$name}->{'consensus'} = $sequence;
	$self->{'contigs'}->{$name}->{'name'} = $name;
	$self->{'contigs'}->{$name}->{"singlet"} = 1;
	$self->{'contigs'}->{$name}->{'class'} = "singlet";
    }
    $self->debug("Bio::Tools::Alignment::Consed::set_singlets: Done adding singlets to the singlets hash.\n");
    $self->{'singlets_set'} = "done";
    return 0;
}				# end sub set_singlets

    my $self = shift;
    my @points;
    $self->debug("Bio::Tools::Alignment::Consed::set_trim_points_doublets: Restoring zeros for doublets.\n");
    # &show_missing_sequence($self);
    $self->debug("Bio::Tools::Alignment::Consed::set_trim_points_doublets: Setting doublet trim points.\n");
    foreach (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'}->{$_}->{'class'} eq "doublet") {
	          # my ($self,$sequence,$quality,$name,$class) = @_;
          my @quals = split(' ',$self->{'contigs'}->{$_}->{'quality'});
          
	    (@points) = $self->{o_trim}->trim_doublet($self->{'contigs'}->{$_}->{'consensus'},$self->{'contigs'}->{$_}->{'quality'},$self->{'contigs'}->{$_}->{name},$self->{'contigs'}->{$_}->{'class'});
	    $self->{'contigs'}->{$_}->{'start_point'} = $points[0];
	    $self->{'contigs'}->{$_}->{'end_point'} = $points[1];
               # now set this
	    $self->{'contigs'}->{$_}->{'sequence_trimmed'} = substr($self->{contigs}->{$_}->{'consensus'},$points[0],$points[1]-$points[0]);
	    # 010102 the deprecated way to do things:
	}
    }
    $self->debug("Bio::Tools::Alignment::Consed::set_trim_points_doublets: Done setting doublet trim points.\n"); 
    return;
}				# end set_trim_points_doublets

    my ($self) = @_;
    $self->debug("Consed.pm :\$ self is $self\n");
    my (@points,$trimmed_sequence);
    if (!$self->{'doublets_set'}) {
        $self->debug("You need to set the doublets before you use set_trim_points_singlets_and_doublets. Doing that now.");
	$self->set_doublets();
    }
    foreach (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'}->{$_}->{'class'} eq "singlet") {
	    $self->debug("Singlet $_\n");
	    # this is what Warehouse wants
	    #         my ($self,$sequence,$quality,$name) = @_;
	    # this is what Bio::Tools::Alignment::Trim::trim_singlet wants:
	    # my ($self,$sequence,$quality,$name,$class) = @_;
	    # the following several lines are to make the parameter passing legible.
	    my ($sequence,$quality,$name,$class);
	    $sequence = $self->{'contigs'}->{$_}->{'consensus'};
	    if (!$self->{'contigs'}->{$_}->{'quality'}) { $quality = "unset"; }
	    else { $quality = $self->{'contigs'}->{$_}->{'quality'}; }
	    $name = $self->{'contigs'}->{$_}->{'name'};
	    $class = $self->{'contigs'}->{$_}->{'class'};	    
	    (@points) = @{$self->{'o_trim'}->trim_singlet($sequence,$quality,$name,$class)};
	    $self->{'contigs'}->{$_}->{'start_point'} = $points[0];
	    $self->{'contigs'}->{$_}->{'end_point'} = $points[1];
	    $self->{'contigs'}->{$_}->{'sequence_trimmed'} = substr($self->{contigs}->{$_}->{'consensus'},$points[0],$points[1]-$points[0]);
	}
    }
    $self->debug("Bio::Tools::Alignment::Consed::set_trim_points_singlets_and_singletons: Done setting the quality trimpoints.\n");
    return;
}				# end set_trim_points_singlet

 (shift)->verbose(@_)

    # decide which sequence should not have been clipped at consensus position = 0
    my $self = shift;
    &get_phreds($self);
    my ($current_contig,@qualities);
    foreach $current_contig (sort keys %{$self->{'contigs'}}) {
	if ($self->{'contigs'}->{$current_contig}->{'class'} eq "doublet") {
	    my $number_leading_xs = 0;
	    my $number_trailing_xs = 0;
	    my $measurer = $self->{'contigs'}->{$current_contig}->{'quality'};
	    while ($measurer =~ s/^\ 0\ /\ /) {
		$number_leading_xs++;
	    }
	    while ($measurer =~ s/\ 0(\s*)$/$1/) {
		$number_trailing_xs++;
	    }
	    @qualities = split(' ',$self->{'contigs'}->{$current_contig}->{'quality'});
	    my $in_initial_zeros = 0;
	    for (my $count=0;$count<scalar(@qualities); $count++) {
		if ($qualities[$count] == 0) {
		    my ($quality,$top_phred_position,$bottom_phred_position,$top_phred_data,$bottom_phred_data);
		    # print("The quality of the consensus at ".($count+1)." is zero. Retrieving the real quality value.\n");
		    # how do I know which strand to get these quality values from????
		    # boggle
		    my $top_quality_here = $self->{'contigs'}->{$current_contig}->{'top_phreds'}->[0-$self->{'contigs'}->{$current_contig}->{'top_start'}+$count+1];
		    my $bottom_quality_here = $self->{'contigs'}->{$current_contig}->{'bottom_phreds'}->[1-$self->{'contigs'}->{$current_contig}->{'bottom_start'}+$count];
		    if (!$bottom_quality_here || (1-$self->{'contigs'}->{$current_contig}->{'bottom_start'}+$count)<0) {
			$bottom_quality_here = "not found";
		    }
		    if (!$top_quality_here) {
			$top_quality_here = "not found";
		    }
		    # print("Looking for quals at position $count of $current_contig: top position ".(0-$self->{'contigs'}->{$current_contig}->{top_start}+$count)." ($self->{'contigs'}->{$current_contig}->{top_name}) $top_quality_here , bottom position ".(1-$self->{'contigs'}->{$current_contig}->{bottom_start}+$count)." ($self->{'contigs'}->{$current_contig}->{bottom_name}) $bottom_quality_here\n"); 
		    if ($count<$number_leading_xs) {
			# print("$count is less then $number_leading_xs so I will get the quality from the top strand\n");
			# print("retrieved quality is ".$self->{'contigs'}->{$current_contig}->{top_phreds}[0-$self->{'contigs'}->{$current_contig}->{top_start}+$count+1]."\n");
			my $quality = $top_quality_here;
			$quality =~ /\S+\s(\d+)\s+/;
			$quality = $1;
			# print("retrieved quality for leading zero $count is $quality\n");
			# t 9 9226
			$qualities[$count] = $quality;
		    }
		    else {
			# this part is tricky
			# if the contig is like this
			#      cccccccccccccccc
			# ffffffffffffffffff
			#          rrrrrrrrrrrrrrrrr
			# then take the quality value for the trailing zeros in the cons. seq from the r
			#
			# but if the contig is like this
			#      cccccccccccccccccc
			#      ffffffffffffffffffffffffffffffff
			# rrrrrrrrrrrrrrrrrrrrrrrxxxxxxxxr
			#                      ^^^
			# then any zeros that fall in the positions (^) must be decided whether the quality
			# is the qual from the f or r strand. I will use the greater number
			# does a similar situation exist for the leading zeros? i dunno
			#
			# print("$count is greater then $number_leading_xs so I will get the quality from the bottom strand\n");
			# print("retrieved quality is ".$contigs->{$current_contig}->{top_phreds}[0-$contigs->{$current_contig}->{top_start}+$count+1]."\n");
			# my ($quality,$top_phred_position,$bottom_phred_position,$top_phred_data,$bottom_phred_data);
			if ($bottom_quality_here eq "not found") {
			    # $top_phred_position = 1-$contigs->{$current_contig}->{bottom_start}+$count;
			    # print("Going to get quality from here: $top_phred_position of the top.\n");
			    # my $temp_quality - $contigs->{$current_contig}->{top_phreds}
			    # $quality = $contigs->{$current_contig}->{top_phreds}[$top_phred_position];
			    $top_quality_here =~ /\w+\s(\d+)\s/;
			    $quality = $1;
			}
			elsif ($top_quality_here eq "not found") {
			    # $bottom_phred_position = 1+$contigs->{$current_contig}->{bottom_start}+$count;
			    # print("Going to get quality from here: $bottom_phred_position of the bottom.\n");
			    # $quality = $contigs->{$current_contig}->{bottom_phreds}[$bottom_phred_position];
			    # print("Additional: no top quality but bottom is $quality\n");
			    $bottom_quality_here =~ /\w+\s(\d+)\s/;
			    $quality = $1;
			}
			else {
			    # print("Oh jeepers, there are 2 qualities to choose from at this position.\n");
			    # print("Going to compare these phred qualities: top: #$top_quality_here# bottom: #$bottom_quality_here#\n");
			    # now you have to compare them
			    # my $top_quality_phred = $contigs->{$current_contig}->{top_phreds}[$top_phred_position];
			    # #t 40 875#
			    # print("regexing #$top_quality_here#... ");
			    $top_quality_here =~ /\w\ (\d+)\s/;
			    my $top_quality = $1;
			    # print("$top_quality\nregexing #$bottom_quality_here#... ");
			    $bottom_quality_here =~ /\w\ (\d+)\s/;
			    my $bottom_quality = $1;
			    # print("$bottom_quality\n");
			    # print("top_quality: $top_quality bottom quality: $bottom_quality\n");
			    if ($bottom_quality > $top_quality) {
				# print("Chose to take the bottom quality: $bottom_quality\n");
				$quality = $bottom_quality;
			    } else {
				# print("Chose to take the top quality: $top_quality\n");
				$quality = $top_quality;
			    }
			}
			if (!$quality) {
			    # print("Warning: no quality value for $current_contig, position $count!\n");
			    # print("Additional data: top quality phred: $top_quality_here\n");
			    # print("Additional data: bottom quality phred: $bottom_quality_here\n");
			} else {
			    $qualities[$count] = $quality;
			}
		    }						
		}

	    }
	    unless (!@qualities) {
		$self->{'contigs'}->{$current_contig}->{'quality'} = join(" ",@qualities);
	    }
	    $self->{'contigs'}->{$current_contig}->{'bottom_phreds'} = undef;
	    $self->{'contigs'}->{$current_contig}->{'top_phreds'} = undef;
	    my $count = 1;
	}			# end foreach key
    }
}


# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__

    my ($self,$total_only) = @_;
    my ($count,$count_multiplets,$multiplet_count);
    my $singlets = &get_singlets($self); $count += $singlets;
    my $doublets = &get_doublets($self); $count += ($doublets * 2);
    my $pairs = &get_pairs($self); $count += ($pairs * 2);
    my $singletons = &get_singletons($self); $count += $singletons;
    my @multiplets = &get_multiplets($self);
    $count_multiplets = @multiplets;
    my $return_string;
    foreach (@multiplets) {
	my $number_members = $self->{'contigs'}->{$_}->{num_members};	
	$multiplet_count += $number_members;
    }
    if ($multiplet_count) {
	$count += $multiplet_count;
    }
    foreach (qw(multiplet_count singlets doublets pairs singletons multiplets count_multiplets)) {
	no strict 'refs';	# renege for the block
	if (!${$_}) {
		${$_} = 0;
	}
    }
	if (!$multiplet_count) { $multiplet_count = 0; }
	if ($total_only) {
		return $count;
	}
	$return_string = "Singt/singn/doub/pair/mult/total : $singlets,$singletons,$doublets(".
            ($doublets*2)."),$pairs(".($pairs*2)."),$count_multiplets($multiplet_count),$count";
	return $return_string;

		# worry about platform dependence here?
		# oh shucksdarn.
	my $self = shift;
	my $stats_filename = $self->{'path'}."statistics";
	my $statistics_raw = $self->sum_lets;
	(my $statsfilecontents = $statistics_raw) =~ s/.*\ \:\ //g;
	umask 0001;
	my $fh = new Bio::Root::IO(-file=>"$stats_filename");
	# open(STATSFILE,">$stats_filename") or print("Could not open the statsfile: $!\n");
	$fh->_print("$statsfilecontents");
	# close STATSFILE;
	$fh->close();

  bioperl-l@bioperl.org                         - General discussion
  http://bio.perl.org/MailList.html             - About the mailing lists

  bioperl-bugs@bio.perl.org
  http://bugzilla.bioperl.org/

 Title   : verbose()
 Usage   : $o_consed->verbose(1);
 Function: Set the verbosity level for debugging messages. On instantiation
	   of the Bio::Tools::Alignment::Consed object the verbosity level
           is set to 0 (quiet).
 Returns : 1 or 0.
 Args    : The verbosity levels are:
	      0 - quiet
	      1 - noisy
	      2 - noisier
	      3 - annoyingly noisy
 Notes   : This method for setting verbosity has largely been superseeded by
	   a sub-by-sub way, where for every sub you can provide a (-verbose)
	   switch. I am doing converting this bit-by-bit so do not be surprised
	   if some subs do not honour this.

 Title   : reverse_recurse(\@source,\@destination)
 Usage   : $o_consed->reverse_recurse(\@source,\@destination);
 Function: A recursive routine to reverse and complement an array of phred
	   data.
 Returns : A reference to an array containing reversed phred data.
 Args    : A reference to a source array and a reverence to a destination
	   array.
 Notes   : Recursion is kewl, but this sub should likely be _reverse_recurse.

 Title   : show_missing_sequence();
 Usage   : $o_consed->show_missing_sequence();
 Function: Used by set_trim_points_doublets() to fill in quality values where
	   consed (phrap?) set them to 0 at the beginning and/or end of the
	   consensus sequences.
 Returns : Nothing.
 Args    : None.
 Notes   : Acts on doublets only. Really very somewhat quite ugly. A
	disgusting kludge. <insert pride here> It was written stepwise with
	no real plan because it was not really evident why consed (phrap?)
	was doing this.