$database_adaptor = new Bio::EnsEMBL::DBSQL::DBAdaptor(
    -host   => 'kaka.sanger.ac.uk',
    -dbname => 'homo_sapiens_core_9_30',
    -pass   => 'anonymous'
  );

  $xf_adaptor = new ExternalFeatureAdaptorSubClass;

  # Connect the Ensembl core database:
  $xf_adaptor->db($database_adaptor);

  # get some features in vontig coords
  @feats =
    @{ $xf_adaptor->fetch_all_by_contig_name('AC000087.2.1.42071') };

  # get some features in assembly coords
  @feats =
    @{ $xf_adaptor->fetch_all_by_chr_start_end( 'X', 100000, 200000 ) };

  # get some features in clone coords
  @feats = @{ $xf_adaptor->fetch_all_by_clone_accession('AC000087') };

  # Add the adaptor to the ensembl core dbadaptor (implicitly sets db
  # attribute)
  $database_adaptor->add_ExternalFeatureAdaptor($xf_adaptor);

  # get some features in Slice coords
  $slice_adaptor = $database_adaptor->get_SliceAdaptor;
  $slice =
    $slice_adaptor->fetch_all_by_chr_start_end( 1, 100000, 200000 );
  @feats = @{ $xf_adaptor->fetch_all_by_Slice($slice) };

  # now features can be retrieved directly from Slice
  @feats = @{ $slice->get_all_ExternalFeatures };

  COORD SYSTEM STRING   FETCH_METHOD
  -------------------   ------------
  'ASSEMBLY'            fetch_all_by_chr_start_end
  'CLONE'               fetch_all_by_clone_accession
  'CONTIG'              fetch_all_by_contig_name
  'SUPERCONTIG'         fetch_all_by_supercontig_name
  'SLICE'               fetch_all_by_Slice

  my $features = shift;

  #we do not know what type of features these are.  They might
  #be bioperl features or old ensembl features, hopefully they are new
  #style features.  Try to come up with a setter method for the
  #slice.

  return undef if(!@$features);

  my ($f) = @$features;

  my $slice_setter;
  foreach my $method (qw(slice contig attach_seq)) {
    last if($slice_setter = $f->can($method));
  }
    
  if(!$slice_setter) {
    if($f->can('seqname')) {
      $slice_setter = sub { $_[0]->seqname($_[1]->seq_region_name()); };
    } else {
      $slice_setter = sub{} if(!$slice_setter);
    }
  }

  return $slice_setter;

  my $self = shift;

  throw("This ExternalFeatureAdaptor does not support a known " .
		"coordinate system.\n Valid coordinate systems are: " .
		"[SLICE,ASSEMBLY,SUPERCONTIG,CONTIG,CLONE].\n This External Adaptor " . 
                "supports: [" . join(', ', $self->coordinate_systems) . "]");

  my ($self, $system) = @_;

  #construct the hash of supported features if it has not been already
  unless(exists $self->{_supported}) {
    $self->{_supported} = {};
    foreach my $coord_system ($self->coordinate_systems) {
      $self->{_supported}->{$coord_system} = 1;
    }
  }

  return $self->{_supported}->{$system};
}
  


1;

  my $self = shift;

  throw("abstract method coordinate_systems not implemented\n");

  return '';

  my ($self, $value) = @_;

  if($value) {
    $self->{'ensembl_db'} = $value;
  }

  return $self->{'ensembl_db'};

  my $self = shift;
  
  return qw(SIMPLE);

  my ($self, $slice) = @_;

  unless($slice && ref $slice && $slice->isa('Bio::EnsEMBL::Slice')) {
    throw("[$slice] is not a Bio::EnsEMBL::Slice");
  }

  my $out = [];

  my $csa = $self->ensembl_db->get_CoordSystemAdaptor();

  my $slice_start  = $slice->start;
  my $slice_end    = $slice->end;
  my $slice_strand = $slice->strand;
  my $slice_seq_region  = $slice->seq_region_name;
  my $slice_seq_region_id  = $slice->get_seq_region_id;
  my $coord_system = $slice->coord_system;

  if($self->_supported('SLICE')) {
    throw("ExternalFeatureAdaptor supports SLICE coordinate system" .
		 " but fetch_all_by_Slice not implemented");
  }

  my %features;
  my $from_coord_system;

  my $fetch_method;

  #
  # Get all of the features from whatever coord system they are computed in
  #
  if($self->_supported('CLONE')) {
    $fetch_method = sub {
      my $self = shift;
      my $name = shift;
      my ($acc, $ver) = split(/\./, $name);
      $self->fetch_all_by_clone_accession($acc,$ver,@_);
    };
    $from_coord_system = $csa->fetch_by_name('clone');
  } elsif($self->_supported('ASSEMBLY')) {
    $from_coord_system = $csa->fetch_by_name('chromosome');
    $fetch_method = $self->can('fetch_all_by_chr_start_end');
  } elsif($self->_supported('CONTIG')) {
    $from_coord_system = $csa->fetch_by_name('contig');
    $fetch_method = $self->can('fetch_all_by_contig_name');
  } elsif($self->_supported('SUPERCONTIG')) {
    $from_coord_system = $csa->fetch_by_name('supercontig');
    $fetch_method = $self->can('fetch_all_by_supercontig_name');
  } else {
    $self->_no_valid_coord_systems();
  }

  if($from_coord_system->equals($coord_system)) {
    $features{$slice_seq_region} = &$fetch_method($self, $slice_seq_region,
                                                  $slice_start,$slice_end);
  } else {
    foreach my $segment (@{$slice->project($from_coord_system->name,
                                           $from_coord_system->version)}) {
      my ($start,$end,$pslice) = @$segment;
      $features{$pslice->seq_region_name } ||= [];
      push @{$features{$pslice->seq_region_name }},
           @{&$fetch_method($self, $pslice->seq_region_name,
                            $pslice->start(),
                            $pslice->end())};
    }
  }

  my @out;

  if(!$coord_system->equals($from_coord_system)) {             
    my $asma = $self->ensembl_db->get_AssemblyMapperAdaptor();
    my $mapper = $asma->fetch_by_CoordSystems($from_coord_system,
                                              $coord_system);
    my %slice_cache;
    my $slice_adaptor = $self->ensembl_db->get_SliceAdaptor();
    my $slice_setter;

    #convert the coordinates of each of the features retrieved
    foreach my $fseq_region (keys %features) {
      my $feats = $features{$fseq_region};
      next if(!$feats);
      $slice_setter = _guess_slice_setter($feats) if(!$slice_setter);

      foreach my $f (@$feats) {
        my($sr_id, $start, $end, $strand) = 
          $mapper->fastmap($fseq_region,$f->start,$f->end,$f->strand,
                           $from_coord_system);
        
        #maps to gap
        next if(!defined($sr_id));

        #maps to unexpected seq region, probably error in the externally
        if($sr_id ne $slice_seq_region_id) {
          warning("Externally created Feature mapped to [$sr_id] " .
                  "which is not on requested seq_region_id [$slice_seq_region_id]");
          next;
        }

        #update the coordinates of the feature
        &$slice_setter($f,$slice);
        $f->start($start);
        $f->end($end);
        $f->strand($strand);
        push @out, $f;
      }
    }
  } else {
    #we already know the seqregion the featues are on, we just have
    #to put them on the slice
    @out = @{$features{$slice_seq_region}};
    my $slice_setter = _guess_slice_setter(\@out);

    foreach my $f (@out) {
      &$slice_setter($f,$slice);
    }
  }

  #shift the feature coordinates again if
  #the requested slice is not the full seqregion
  if($slice->start != 1 || $slice->strand != 1) {
    #convert from assembly coords to slice coords
    my($f_start, $f_end, $f_strand);
    foreach my $f (@out) {
      if($slice_strand == 1) {
        $f_start  = $f->start - $slice_start + 1;
        $f_end    = $f->end   - $slice_start + 1;
        $f_strand = $f->strand;
      } else {
        $f_start  = $slice_end - $f->end   + 1;
        $f_end    = $slice_end - $f->start + 1;
        $f_strand = $f->strand * -1;
      }
    
      $f->start($f_start);
      $f->end($f_end);
      $f->strand($f_strand);
    }
  }
  
  return\@ out;

  my ($self, $chr_name, $start, $end) = @_;

  unless($chr_name && defined $start && defined $end && $start < $end) {
    throw("Incorrect start [$start] end [$end] or chr [$chr_name] arg");
  }

  unless($self->ensembl_db) {
    throw('DB attribute not set.  This value must be set for the ' .
		 'ExternalFeatureAdaptor to function correctly');
  }

  my $slice_adaptor = $self->ensembl_db->get_SliceAdaptor();

  my $slice = $slice_adaptor->fetch_by_region('toplevel', $chr_name, $start,
                                              $end);

  return $self->fetch_all_by_Slice($slice);

  my ($self, $acc, $version, $start, $end) = @_;

  unless($acc) {
    throw("clone accession argument not defined");
  }

  if($self->_supported('CLONE')) {
    throw('ExternalFeatureAdaptor supports CLONE coordinate system ' .
		 'but does not implement fetch_all_by_clone_accession');
  }

  unless($self->ensembl_db) {
    throw('DB attribute not set.  This value must be set for the ' .
		 'ExternalFeatureAdaptor to function correctly');
  }

  if(defined($version)) {
    $acc = "$acc.$version";
  } elsif(!$acc =~ /\./) {
    $acc = "$acc.1";
  }

  my $slice_adaptor = $self->ensembl_db->get_SliceAdaptor;

  my $slice = $slice_adaptor->fetch_by_region('clone', $acc, $start, $end);

  return $self->fetch_all_by_Slice($slice);

  my ($self, $contig_name, $start, $end) = @_;

  unless($contig_name) {
    throw("contig_name argument not defined");
  }

  if($self->_supported('CONTIG')) {
    throw("ExternalFeatureAdaptor supports CONTIG coordinate system" .
		 " but fetch_all_by_contig_name is not implemented");
  }

  unless($self->ensembl_db) {
    throw('DB attribute not set.  This value must be set for the ' .
		 'ExternalFeatureAdaptor to function correctly');
  }

  my $slice_adaptor = $self->ensembl_db->get_SliceAdaptor();
  my $slice = $slice_adaptor->fetch_by_region('contig', $contig_name,
                                             $start, $end);
  return $self->fetch_all_by_Slice($slice);

  my ($self, $supercontig_name, $start, $end) = @_;

  unless($supercontig_name) {
    throw("supercontig_name argument not defined");
  }

  if($self->_supported('SUPERCONTIG')) {
    throw("ExternalFeatureAdaptor supports SUPERCONTIG coordinate system" .
		 " but fetch_all_by_supercontig_name is not implemented");
  }

  unless($self->ensembl_db) {
    throw('DB attribute not set.  This value must be set for the ' .
		 'ExternalFeatureAdaptor to function correctly');
  }

  my $slice_adaptor = $self->ensembl_db->get_SliceAdaptor();
  my $slice = $slice_adaptor->fetch_by_region('supercontig', $supercontig_name,
                                             $start, $end);
  return $self->fetch_all_by_Slice($slice);

  my $class = shift;

  if(ref $class) {
    return bless {}, ref $class;
  }

  return bless {}, $class;

  my $self = shift;

  return 'External features';

  Copyright (c) 1999-2009 The European Bioinformatics Institute and
  Genome Research Limited.  All rights reserved.

  This software is distributed under a modified Apache license.
  For license details, please see

    /info/about/code_licence.html

  Please email comments or questions to the public Ensembl
  developers list at <ensembl-dev@ebi.ac.uk>.

  Questions may also be sent to the Ensembl help desk at
  <helpdesk@ensembl.org>.