my ($self,$feature,$cluster) = @_;
  if (defined($feature)) {
    $self->throw("exon must be a Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    if (defined $cluster){
      $self->throw("Cluster must be a Bio::EnsEMBL::Analysis::Tools::Algorithms::ExonCluster not a ".ref($cluster)."\n")
	unless $cluster->isa("Bio::EnsEMBL::Analysis::Tools::Algorithms::ExonCluster");
    }
    my $key = $self->_get_key_from_feature($feature);
    $self->{_exoncluster}{$key} = $cluster;
  }
  return;

  my ($self,$feature,$type) = @_;
  unless ($type eq 'exon' or $type eq 'intron'){
    $self->throw("Feature must be defined as in intron or an exon");
  }
  if (defined($feature)) {
    my $key = $self->_get_key_from_feature($feature);
    # store associated features along with the feature
    $self->add_ev_by_feature($feature);
    # exons are more coplictated because of supporting features
    # and end exons
    if ($type eq 'exon'){
      # single exons are terminal but not 3 or 5 prime
      $self->add_exon_count($feature);
      if ($feature->is_terminal_exon && $feature->number_exons > 1 ){
	my $terminal_key = $self->_get_key_from_terminal_feature($feature);
	$self->{'_endexoncount'}{$terminal_key}++;
	$self->add_ev_by_terminal_feature($feature);	
	# only store the terminal exon if it is the longest
	# otherwise just transfer the supporting features
	if (my $existing_end_exon =  $self->get_end_exon($feature)){
	  # push supporting features onto the feature if it exists
	  if ($existing_end_exon->length < $feature->length){
	    $self->{'_endexonhash'}{$terminal_key} = $feature;
	  }
	} else {
	  # end exon hasnt been added before 
	  $self->{'_endexonhash'}{$terminal_key} = $feature;
	}
      }
      if (my $existing_exon =  $self->get_exon($feature)){
	my @sfs = @{$existing_exon->get_all_supporting_features};
	$feature->add_supporting_features(@sfs);
	$self->{'_exonhash'}{$key} = $feature;
      } else {
	# its a new exon add it for the first time
	$self->{'_exonhash'}{$key} = $feature;	
      }
      # no point in adding get exon by start if its the first exon
      $self->add_exon_by_start($feature) unless $key =~ /start/;
      $self->add_exon_by_end($feature) unless $key =~ /end/;
      # want to store *all* the transcripts that share this exon
      my $transcript = $feature->transcript;
      $self->transcript_by_feature($feature,$transcript);
    }
    # introns are nice and easy
    if ($type eq 'intron'){
      $self->add_intron_count($feature);
      $self->{'_intronhash'}{$key} = $feature;
    }
  }
  return ;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    if ($feature->start && $feature->end && $feature->strand && $feature->seq_region_name){
      my $key = $feature->seq_region_name.':'.$feature->start.':'.$feature->end.':'.$feature->strand;
      $self->throw("Key not found for $feature\n") unless $key;
      return $key;
    }
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {    
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key;
    return 0 unless $feature->is_terminal_exon;
    if (($feature->is_5prim_exon && $feature->strand == 1) or
	($feature->is_3prim_exon && $feature->strand == -1) ){
      $key =  $feature->seq_region_name.':start:'.$feature->end.':'.$feature->strand;
    }
    if (($feature->is_3prim_exon && $feature->strand == 1) or
	($feature->is_5prim_exon && $feature->strand == -1) ){
      $key =  $feature->seq_region_name.':'.$feature->start.':end:'.$feature->strand;
    }
    return $key;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    my $evidence = $feature->ev_set;
    $self->throw("No evidence set found for $feature\n") unless $evidence;
    $self->{_evidencecount}{$key}{$evidence}++;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_terminal_feature($feature);
    my $evidence = $feature->ev_set;
    $self->throw("No evidence set found for $feature\n") unless $evidence;
    $self->{_terminalevidencecount}{$key}{$evidence}++;
  }
  return;

  my ($self,$feature,$cluster) = @_;
  if (defined($feature)) {
    $self->throw("exon must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    $self->_add_feature($feature,'exon');
  }
  if (defined($cluster)){
    $self->_add_exoncluster($feature,$cluster);
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    my $start = $feature->end.":".$feature->strand;
    $self->{_exonends}{$start}{$key} = $feature;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    my $start = $feature->start.":".$feature->strand;
    $self->{_exonstarts}{$start}{$key} = $feature;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    $self->{_exoncount}{$key}++;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)){
    $self->throw("Intron must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    $self->_add_feature($feature,'intron');
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {    
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    $self->{_introncount}{$key}++;
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    if ( $self->{_exonhash}{$key} ){
      return 1;
    }
    else {
      return 0;
    }
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    if ( $self->{_intronhash}{$key} ){
      return 1;
    }
    else {
      return 0;
    }
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    return 0 unless $feature->is_terminal_exon;
    my $key = $self->_get_key_from_terminal_feature($feature);
    return $self->{_endexoncount}{$key};
  }
  return;

  my ($self,$feature,$ev_set) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
   my $key = $self->_get_key_from_feature($feature);
    if (defined($ev_set)) {
      if ($self->{_evidencecount}{$key}{$ev_set}){
	return $self->{_evidencecount}{$key}{$ev_set};
      } else {
	return 0;
      }
    }
  }
  return 0;

  my ($self,$feature,$ev_set) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_terminal_feature($feature);
    if (defined($ev_set)) {   
      if ($self->{_terminalevidencecount}{$key}{$ev_set}){
	return $self->{_terminalevidencecount}{$key}{$ev_set} ;
      } else {
	return 0;
      }
    }
  }
  return 0;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    print "$key";
  }

  my ($self,$feature,$score) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    if  (defined($score)) {
      $self->{_exonscore}{$key} = $score;
    }
    return $self->{_exonscore}{$key};
  }
  return;

  my ($self) = @_;
  my @exons = values %{$self->{'_exonhash'}};
  @exons = sort {$a->start <=> $b->start} @exons;
  return\@ exons;

  my ($self) = @_;
  my @introns =values %{$self->{_intronhash}};
  @introns  = sort {$a->start <=> $b->start} @introns;
  return\@ introns;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    return 0 unless $feature->is_terminal_exon;
    my $key = $self->_get_key_from_terminal_feature($feature);
    return $self->{_endexonhash}{$key};
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    return $self->{_exonhash}{$key};
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    return $self->{_exoncluster}{$key};
  }
  return;
}


1;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    return $self->{_exoncount}{$key};
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    return $self->{_introncount}{$key};
  }
  return;

  my ($self,$feature,$score) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    if  (defined($score)) {
      $self->{_intronscore}{$key} = $score;
    }
    return $self->{_intronscore}{$key};
  }
  return;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $start = $feature->start.":".$feature->strand;
    my @exons = values %{$self->{_exonends}{$start}};
    return\@ exons;
  }
  return;

  my ($self,$exon1,$exon2) = @_;
  if (defined($exon1) && defined($exon2)) {
    $self->throw("exon1 must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($exon1)."\n")
      unless $exon1->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    $self->throw("exon2 must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($exon2)."\n")
      unless $exon2->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my @array = ( $exon1, $exon2 );
    # sort them my start
    @array = sort { $a->start <=> $b->start } @array;
    my $intron = Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended->new
      (
       -start   => $array[0]->end,
       -end     => $array[1]->start,
       -strand  => $exon1->strand,
       -slice   => $exon1->slice,
       -analysis=> $exon1->transcript->analysis,
      );
    return $intron;
  }
  return;

  my($class) = shift;
  if( ref $class ) {
      $class = ref $class;
  }
  my $self = $class->SUPER::new(@_);

  $self->{_exonhash} = undef;
  $self->{_endexonhash} = undef;
  $self->{_intronhash} = undef;
  $self->{_exonstarts} = undef;
  $self->{_intronstarts} = undef;
  $self->{_exoncluster} = undef;
  $self->{_evidencecount} = undef;
  $self->{_featurecount} = undef;
  $self->{_score} = undef;
  $self->{_endexon} = undef;
  $self->{_exontranscript} = undef;

  return $self ;

  my ($self,$feature) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $start = $feature->end.":".$feature->strand;
    my @exons = values %{$self->{_exonstarts}{$start}};
    return\@ exons;
  }
  return;

  my ($self,$feature,$trans) = @_;
  if (defined($feature)) {
    $self->throw("Feature must be a Bio::EnsEMBL::Analysis:Tools::GeneBuildUtils::ExonExtended not a ".ref($feature)."\n")
      unless $feature->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended");
    my $key = $self->_get_key_from_feature($feature);
    if  (defined($trans)) {
    $self->throw("Transcript must be a Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::TranscriptExtended not a ".ref($trans)."\n")
      unless $trans->isa("Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::TranscriptExtended");
      push (@{$self->{_exontranscript}{$key}}, $trans);
    }
    return $self->{_exontranscript}{$key};
  }
  return;

   Name       : add_feature
   Arg[0]     : Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended
   Arg[1]     : (optional) string
   Function   : Stores an exon or intron feature in a hash keyed on its genomic coordinates
              : If an identical feature has already been stored it transfers the supporting features
              : Stores how many identical features have been stored so far.
              : Stores end exons in a seperate hash to aid idenifying the longest end exon in the stack
   Exceptions : Throws unless ARG[0] is a Bio::EnsEMBL::Analysis::Tools::GeneBuildUtils::ExonExtended object
              : Throws unless ARG[1] is 'exon' or 'intron'
   Returnval  : none