use Bio::EnsEMBL::ExternalData::Family::DBSQL::DBAdaptor;
  use Bio::EnsEMBL::ExternalData::Family::FamilyAdaptor;
  use Bio::EnsEMBL::ExternalData::Family::Family;

  $famdb = Bio::EnsEMBL::ExternalData::Family::DBSQL::DBAdaptor->new(
					     -user   => 'myusername',
                                             -dbname => 'myfamily_db',
                                             -host   => 'myhost',
                                              );

  my $fam_adtor = $famdb->get_FamilyAdaptor;

  my $fam = $fam_adtor->fetch_by_stable_id('ENSP00000012304');

  print $fam->description, join('; ',$fam->keywords,$fam->release, 
    $fam->annotation_confidence_score, $fam->size);

  my ($self,$value)= @_;
  
  if (defined $value) {
    $self->{'adaptor'} = $value;
  }

  return $self->{'adaptor'};

     my ($self, $member) = @_; 
    
    $member->isa('Bio::EnsEMBL::ExternalData::Family::FamilyMember') ||
      $self->throw("You have to add a Bio::EnsEMBL::ExternalData::Family::FamilyMember object, not a $member");
   
    push @{$self->{_members}}, $member;
    push @{$self->{_members_by_dbname}{$member->database}}, $member;
    push @{$self->{_members_by_dbname_taxon}{$member->database."_".$member->taxon_id}}, $member;

    my ($self,$value) = @_;
    if( defined $value) {
	$self->{'annotation_confidence_score'} = $value;
    }
    return $self->{'annotation_confidence_score'};

    my ($self,$value) = @_;
    if( defined $value) {
	$self->{'dbID'} = $value;
    }
    return $self->{'dbID'};

    my ($self,$value) = @_;
    if( defined $value) {
	$self->{'desc'} = $value;
    }
    return $self->{'desc'};

  my ($self) = @_;

  $self->warn("Family->each_member is a deprecated method!
Calling Family->get_all_members instead!");
  
  return $self->get_all_members;

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

  $self->warn("Family->each_member_of_db is a deprecated method!
Calling Family->get_members_by_dbname instead!");
  
  return $self->get_members_by_dbname($dbname);

  my ($self, $dbname, $taxon_id) = @_;

  $self->warn("Family->each_member_of_db_taxon is a deprecated method!
Calling Family->get_members_by_dbname_taxon instead!");
  
  return $self->get_members_by_dbname_taxon($dbname,$taxon_id);
}

1;

  my $self = shift;
  
  my $sa = Bio::SimpleAlign->new();

  #Hack to try to work with both bioperl 0.7 and 1.2:
  #Check to see if the method is called 'addSeq' or 'add_seq'
  my $bio07 = 0;
  if(!$sa->can('add_seq')) {
    $bio07 = 1;
  }
  
  foreach my $member (@{$self->get_all_members}) {
    my $seqstr = $member->alignment_string;
    next if(!$seqstr);
    my $seq = Bio::LocatableSeq->new(-SEQ    => $seqstr,
                                     -START  => 1,
                                     -END    => length($seqstr),
                                     -ID     => $member->stable_id,
                                     -STRAND => 0);
    
    if($bio07) {
      $sa->addSeq($seq);
    } else {
      $sa->add_seq($seq);
    }
  }

  return $sa;

  my ($self, $dbname) = @_;
  
  $self->throw("Should give defined databasename as argument\n") unless (defined $dbname);

  my $family_id = $self->dbID;
  my $FamilyAdaptor = $self->adaptor;

  return $FamilyAdaptor->fetch_Taxon_by_dbname_dbID($dbname,$family_id);

  my ($self) = @_;
  
  unless (defined $self->{'_members'}) {
    my $family_id = $self->dbID;
    my $FamilyMemberAdaptor = $self->adaptor->db->get_FamilyMemberAdaptor();
    my $members = $FamilyMemberAdaptor->fetch_by_family_id($family_id);
    $self->{_members} = [];
    $self->{_members_by_dbname} = {};
    $self->{_members_by_dbname_taxon} = {};
    foreach my $member (@{$members}) {
      $self->add_member($member);
    }
  }
#  return @{$self->{'_members'}};
  return $self->{'_members'};

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

  $self->throw("Should give defined databasename as arguments\n") unless (defined $dbname);

  unless (defined $self->{_members_by_dbname}->{$dbname}) {
    my $family_id = $self->dbID;
    my $FamilyMemberAdaptor = $self->adaptor->db->get_FamilyMemberAdaptor();
    my $members = $FamilyMemberAdaptor->fetch_by_family_dbname($family_id,$dbname);

    $self->{_members_by_dbname}->{$dbname} = [];
    push @{$self->{_members_by_dbname}->{$dbname}}, @{$members};
  }
#  return @{$self->{_members_by_dbname}->{$dbname}};
  return $self->{_members_by_dbname}->{$dbname};

  my ($self, $dbname, $taxon_id) = @_;

  $self->throw("Should give defined databasename and taxon_id as arguments\n") unless (defined $dbname && defined $taxon_id);

  unless (defined $self->{_members_by_dbname_taxon}->{$dbname."_".$taxon_id}) {
    my $family_id = $self->dbID;
    my $FamilyMemberAdaptor = $self->adaptor->db->get_FamilyMemberAdaptor();
    my $members = $FamilyMemberAdaptor->fetch_by_family_dbname_taxon($family_id,$dbname,$taxon_id);

    $self->{_members_by_dbname_taxon}->{$dbname."_".$taxon_id} = [];
    push @{$self->{_members_by_dbname_taxon}->{$dbname."_".$taxon_id}}, @{$members};
  }
#  return @{$self->{_members_by_dbname_taxon}->{$dbname."_".$taxon_id}};
  return $self->{_members_by_dbname_taxon}->{$dbname."_".$taxon_id};

  my($class,@args) = @_;
  
  my $self = $class->SUPER::new(@args);
  
  if (scalar @args) {
     #do this explicitly.
     my ($dbid, $stable_id,$descr,$release, $score, $memb,$adap) = $self->_rearrange([qw(DBID STABLE_ID DESCRIPTION RELEASE SCORE MEMBERS ADAPTOR)], @args);
      
      $dbid && $self->dbID($dbid);
      $stable_id || $self->throw("Must have a stable_id");
      $self->stable_id($stable_id);

      $descr || $self->throw("family must have a description");
      $self->description($descr);

      $release && $self->release($release);
      $score && $self->annotation_confidence_score($score);
      $self->{_members} = []; 
      push (@{$self->{_members}},@{$memb});
      $adap && $self->adaptor($adap);
  }
  
  return $self;

  my $self = shift;
  my $file = shift;

  my %align_hash;
  my $FH = IO::File->new();
  $FH->open($file) || $self->throw("Could not open alignment file [$file]");

  <$FH>; #skip header
  while(<$FH>) {
    next if($_ =~ /^\s+/);  #skip lines that start with space
    
    my ($id, $align) = split;
    $align_hash{$id} ||= '';
    $align_hash{$id} .= $align;
  }

  $FH->close;

  #place all family members in a hash on their names
  my %member_hash;
  foreach my $member (@{$self->get_all_members}) {
    $member_hash{$member->stable_id} = $member;
  }

  #assign alignment strings to each of the members
  foreach my $id (keys %align_hash) {
    my $member = $member_hash{$id};
    if($member) {
      $member->alignment_string($align_hash{$id});
    } else {
      $self->warn("No member for alignment portion: [$id]");
    }
  }
}





###########################################
#
# Deprecated methods. Will be deleted soon.

    my ($self,$value) = @_;
    if( defined $value) {
	$self->{'release'} = $value;
    }
    return $self->{'release'};

  my ($self) = @_; 
  
  # we do not want to have a total number of gene+peptide members (that is non sense)
  # That is why we substracte from the total those corresponding to genes
  # Need to be fixed as ENSEMBLGENE is here hard coded
  # Probably by just adding a colunm type in external_db, which would be gene, peptide, or
  # even transcript. Then recode size as size_by_type or something like that.
  # size_by_type('peptide'),...

  return scalar @{$self->get_all_members} - $self->size_by_dbname('ENSEMBLGENE');

  my ($self, $dbname) = @_; 
  
  $self->throw("Should give a defined databasename as argument\n") unless (defined $dbname);
  
  return scalar @{$self->get_members_by_dbname($dbname)};

  my ($self, $dbname, $taxon_id) = @_; 
  
  $self->throw("Should give defined databasename and taxon_id as arguments\n") unless (defined $dbname && defined $taxon_id);

  return scalar @{$self->get_members_by_dbname_taxon($dbname,$taxon_id)};

    my ($self,$value) = @_;
    if( defined $value) {
	$self->{'stable_id'} = $value;
    }
    return $self->{'stable_id'};

 Philip Lijnzaad <Lijnzaad@ebi.ac.uk> [original perl modules]
 Anton Enright <enright@ebi.ac.uk> [TRIBE algorithm]
 Elia Stupka <elia@fugu-sg.org> [refactoring]
 Able Ureta-Vidal <abel@ebi.ac.uk> [multispecies migration]