my $feat  = new Bio::SeqFeature::FeaturePair(-feature1 => $f1,
						 -feature2 => $f2,
					      );

    # Bio::SeqFeatureI methods can be used

    my $start = $feat->start;
    my $end   = $feat->end;

    # Bio::FeaturePair methods can be used
    my $hstart = $feat->hstart;
    my $hend   = $feat->hend;

   my $feature1 = $feat->feature1;  # returns feature1 object

    my $fp = new Bio::SeqFeature::FeaturePair(-feature1 => $f1,   # genomic
					      -feature2 => $f2,   # protein
					      );

    my $gstart = $fp->start  # returns start coord on feature1 - genomic seq.
    my $gend   = $fp->end    # returns end coord on feature1.

    my $pstart = $fp->hstart # returns start coord on feature2 = protein seq.
    my $pend   = $fp->hend   # returns end coord on feature2.

    $feat->invert

    $feat->start # etc. returns data in $feature2 object

    my ($class, @args) = @_;

    #
    # We've got a certain problem here that somewhat relates to chicken and
    # eggs. The problem is, we override a lot of SeqFeatureI methods here
    # to delegate them to either feature1 or feature2. If we pass along
    # those attributes right away, we need feature1 or feature2 or the feature
    # factory in place, or there is no way around the dreaded default, which
    # is ugly too (as it necessitates subsequent copying if you wanted a
    # different feature object class).
    #
    # So I decided to go with the lesser of two evils here: we need to assume
    # here that we can set all attributes through set_attributes(), which we
    # assume is no different from setting them through the constructor. This
    # gives us a window to set the feature objects and the factory, such that
    # any derived class doesn't have to worry about this any more.
    #
    # I'm happy to hear a better solution, but I think this one isn't so bad.
    #
    my $self = $class->SUPER::new();
    my ($feature1,$feature2,$featfact) = 
	$self->_rearrange([qw(FEATURE1
			      FEATURE2
			      FEATURE_FACTORY
			      )],@args);
    
    $self->_register_for_cleanup(\&cleanup_fp);
    # initialize the feature object factory if not provided
    if(! $featfact) {
	$featfact = Bio::Factory::ObjectFactory->new(
				   -type => "Bio::SeqFeature::Generic",
				   -interface => "Bio::SeqFeatureI");
    }
    $self->feature_factory($featfact);
    # Store the features in the object
    $feature1 && $self->feature1($feature1);
    $feature2 && $self->feature2($feature2);
    
    # OK. Now we're setup to store all the attributes, and they'll go right
    # away into the right objects.
    $self->set_attributes(@args);

    # done - we hope
    return $self;

    my ($self,$arg) = @_;    
    if ( defined($arg) || !defined $self->{'feature1'} ) {
	$self->throw("internal error: feature factory not set!") 
	    unless $self->feature_factory;
	$arg = $self->feature_factory->create_object() unless( defined $arg);
	$self->throw("Argument [$arg] must be a Bio::SeqFeatureI") 
	    unless (ref($arg) && $arg->isa("Bio::SeqFeatureI"));
	$self->{'feature1'} = $arg;
    }
    return $self->{'feature1'};

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

    if ( defined($arg) || ! defined $self->{'feature2'}) {
	$self->throw("internal error: feature factory not set!") 
	    unless $self->feature_factory;
	$arg = $self->feature_factory->create_object() unless( defined $arg);
	$self->throw("Argument [$arg] must be a Bio::SeqFeatureI") 
	    unless (ref($arg) && $arg->isa("Bio::SeqFeatureI"));
	$self->{'feature2'} = $arg;
    }
    return $self->{'feature2'};

    return shift->feature1->start(@_);

    return shift->feature1->end(@_);

    return shift->feature1->strand(@_);

    return shift->feature1->location(@_);

    return shift->feature1->score(@_);

    return shift->feature1->frame(@_);

    return shift->feature1->primary_tag(@_);

    return shift->feature1->source_tag(@_);

    return shift->feature1->seq_id(@_);

    return shift->feature2->seq_id(@_);

    return shift->feature2->start(@_);

    return shift->feature2->end(@_);

    return shift->feature2->strand(@_);

    return shift->feature2->score(@_);

    return shift->feature2->frame(@_);

    return shift->feature2->primary_tag(@_);

    return shift->feature2->source_tag(@_);

    my ($self) = @_;

    my $tmp = $self->feature1;
    
    $self->feature1($self->feature2);
    $self->feature2($tmp);
    return undef;

    my $self = shift;

    return $self->{'feature_factory'} = shift if @_;
    return $self->{'feature_factory'};

    my $self = shift;
    $self->warn("SeqFeatureI::seqname() is deprecated. Please use seq_id() instead.");
    return $self->hseq_id(@_);

    my $self = shift;
    $self->{'feature1'} = $self->{'feature2'} = undef;

 Title   : seqname
 Usage   : $obj->seq_id($newval)
 Function: There are many cases when you make a feature that you
           do know the sequence name, but do not know its actual
           sequence. This is an attribute such that you can store 
           the seqname.

           This attribute should *not* be used in GFF dumping, as
           that should come from the collection in which the seq
           feature was found.
 Returns : value of seqname
 Args    : newvalue (optional)