package MOBY::CrossReference;

#$Id: CrossReference.pm,v 1.3 2008/09/02 13:14:18 kawas Exp $
use strict;
use Carp;
use vars qw($AUTOLOAD @ISA);

use vars qw /$VERSION/;
$VERSION = sprintf "%d.%02d", q$Revision: 1.3 $ =~ /: (\d+)\.(\d+)/;

=head1 NAME

MOBY::Client::CrossReference - a small object describing a MOBY Simple input/output article

=head1 SYNOPSIS

   use MOBY::CrossReference;
   # do stuff with xref ... read below


=cut

=head1 DESCRIPTION

This holds all of the relevant information for a MOBY cross reference
of either the Xref type, or the Object type.  Object cross-references
have only namespace and id attributes, while Xref cross-references
have namespace, id, authURI, serviceName, xref_type, and evidence_code
attributes.  To determine which type of cross-reference you have
in-hand, call the "type" method.

=head1 AUTHORS

Mark Wilkinson (markw at illuminae dot com)

=head1 METHODS

=head2 new

 Usage     :	my $XR = MOBY::Client::CrossReference->new(%args)
 Function  :	create SimpleArticle object
 Returns   :	MOBY::Client::CrossReference object
 Args      :    type      => object || xref (required)
                namespace => $ns            (required)
                id        => $id            (required)
                authURI   => $authURI
                serviceName => $serviceName
                evidence_code => $evidence_code
                xref_type=> $xref_ontology_term
                Object  =>  The XML of a base MOBY Object in this ns/id


=head2 type

 Usage     :	$type = $XR->type($name)
 Function  :	get/set type attribute
 Returns   :	string;  returns last value if new value set
 Arguments :    (required)one of "xref" or "object", depending on the
                type of cross-ref you are making (new, or v0.5 API)

=head2 namespace

 Usage     :	$ns = $XR->namespace($ns)
 Function  :	get/set namespace
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) string representing namespace to set

=head2 id

 Usage     :	$id = $XR->id($id)
 Function  :	get/set id for the cross-reference
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) the id of the cross-reference

=head2 authURI

 Usage     :	$auth = $XR->authURI($auth)
 Function  :	get/set id for the authority for the xref
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) the new authority of the xref type reference

=head2 serviceName

 Usage     :	$name = $XR->serviceName($name)
 Function  :	get/set serviceName for the cross-reference
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) the new serviceName of the cross-reference

=head2 evidence_code

 Usage     :	$code = $XR->evidence_code($code)
 Function  :	get/set evidence_code for the cross-reference
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) the evidence_code of the cross-reference

=head2 xref_type

 Usage     :	$xreftype = $XR->xref_type($xreftype)
 Function  :	get/set xref_type for the cross-reference
 Returns   :	string; returns last value if new value set
 Arguments :    (optional) the xref_type of the cross-reference

=head2 Object

 Usage     : $XML = $XR->Object()
 Function  : retrieve a base MOBY Object XML (e.g. to send to a service)
 Returns   : XML or empty string if there is no namespace or id value

=cut

{

# Why do these methods return the PREVIOUS value of their respective variables?
# How would that be useful?
# Seems more intuitive to return new value, or perhaps even the object itself.
  sub type {
    # only two types are permitted.
    my ( $self, $type ) = @_;
    if ($type && ($type =~ /^(xref|object)$/)) {
      my $old = $self->{_type};
      $self->{_type} = $type;
      return $old;
    }
    return $self->{_type};
  }

  sub namespace {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_namespace};
      $self->{_namespace} = $type;
      return $old;
    }
    return $self->{_namespace};
  }

  sub id {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_id};
      $self->{_id} = $type;
      return $old;
    }
    return $self->{_id};
  }

  sub authURI {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_authURI};
      $self->{_authURI} = $type;
      return $old;
    }
    return $self->{_authURI};
  }

  sub serviceName {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_serviceName};
      $self->{_serviceName} = $type;
      return $old;
    }
    return $self->{_serviceName};
  }

  sub evidence_code {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_evidenceCode};
      $self->{_evidenceCode} = $type;
      return $old;
    }
    return $self->{_evidenceCode};
  }

  sub xref_type {
    my ( $self, $type ) = @_;
    if ($type) {
      my $old = $self->{_xref_type};
      $self->{_xref_type} = $type;
      return $old;
    }
    return $self->{_xref_type};
  }
}

sub new {
  my ( $caller, %args ) = @_;
  my $caller_is_obj = ref($caller);
  return $caller if $caller_is_obj;
  my $class = $caller_is_obj || $caller;
  my $proxy;
  my $self = bless {}, $class;
  while ( my ( $key, $value ) = each %args ) {
    $self->$key($value);
  }
  return undef unless ( $self->type && $self->namespace && $self->id );
  return $self;
}

sub Object {
  my ($self) = @_;
  return "" unless ( $self->namespace && $self->id );
  return "<moby:Object moby:namespace='"
    . ( $self->namespace )
      . "' moby:id='"
	. ( $self->id ) . "'/>";
}
sub DESTROY { }
1;