MOBY::Client::SimpleArticle - a small object describing the Simple articles from the findService Response message of MOBY Central

    foreach my $queryID(keys %$inputs){
        my $this_invocation = $inputs->{$queryID};  # this is the <mobyData> block with this queryID
	my $invocation_output = "";
	if (my $input = $this_invocation->{'This_articleName'}){
            # $input contains a MOBY::Client::SimpleArticle, ::CollectionArticle or ::SecondaryArticle
            next unless $input->isSimple;
	    $XML = $input->XML;  # get the raw XML of the object, including <Simple> or <Collection> elements
            $moby_object = $input->content; # get the raw XML of the object EXCLUDING <Simple> or <Collection> elements
            $DOM = $input->XML_DOM;  # get the XML as a LibXML DOM object
            $namespace = $input->namespace;  # get the namespace of the object
            $id = $input->id;  # get the id of the object (the id of the outermost MOBY object XML block)

            # do your business here and fill $invocation_output
	}

        $MOBY_RESPONSE .= simpleResponse( # create an empty response for this queryID
                $invocation_output   # response for this query
                , "myOutput"  # the article name of that output object
                , $queryID);    # the queryID of the input that we are responding to
    }
    return SOAP::Data->type('base64' => (responseHeader("illuminae.com") . $MOBY_RESPONSE . responseFooter));   

 Usage     :	my $SA = MOBY::Client::SimpleArticle->new(%args)
 Function  :	create SimpleArticle object
 Returns   :	MOBY::Client::SimpleArticle object
 Args      :    either of the following two methods may be used to auto-generate the
                object by passing the appropriate XML node as a string, or XML::DOM node object

                XML => $XML
                XML_DOM => $XML::LibXML::Node

 Usage     :	$name = $SA->articleName($name)
 Function  :	get/set articleName
 Returns   :	string
 Arguments :    (optional) string representing articleName to set

 Usage     :	$type = $SA->objectType($type)
 Function  :	get/set name
 Returns   :	string
 Arguments :    (optional) string representing objectType to set

 Usage     :	$type = $SA->objectLSID($type)
 Function  :	get/set LSID
 Returns   :	string
 Arguments :    (optional) string representing objectLSID to set

 Usage     :	$namespace = $SA->namespace
 Function  :	get namespace for the MOBY Object
 Returns   :	namespace as a string
 Arguments :    none

 Usage     :	$namespaces = $SA->namespaces(\@namespaces)
 Function  :	get/set namespaces for the objectType in a service instance object
 Returns   :	arrayref of namespace strings
 Arguments :    (optional) arrayref of namespace strings to set

 Usage     :   $SA = $SA->XML($XML)
 Function  :	set/reset all parameters for this object from the XML
 Returns   :	MOBY::Client::SimpleArticle
 Arguments :    (optional) XML fragment from and including <Simple>...</Simple>

 Usage     :	$XML = $SA->content
 Function  :	get XML of the article EXCLUDING the <Simple>..</Simple> tags
 Returns   :	string
 Arguments :    none

 Usage     :	$namespaces = $SA->XML_DOM($XML_DOM_NODE)
 Function  :	set/reset all parameters for this object from the XML::DOM node for <Simple>
 Returns   :	MOBY::Client::SimpleArticle
 Arguments :    (optional) an $XML::DOM node from the <Simple> article of a DOM

 Usage     :	$namespaces = $IN->addNamespace($namespace)
 Function  :	add another namespace for the objectType
 Returns   :	namespace string

 Usage     :	$boolean = $IN->isSimple()
 Function  :	is this a SimpleArticle type
                (yes, I know this is obvious, but since you can
                 get both Simple and Collection objects in your
                 Input and output lists, it is good to be able
                 to test what you have in-hand)
 Returns   :	1 (true)

 Usage     :	$boolean = $IN->isCollection()
 Function  :	is this a CollectionArticle type
                (yes, I know this is obvious, but since you can
                 get both Simple and Collection objects in your
                 Input and output lists, it is good to be able
                 to test what you have in-hand)
 Returns   :	0 for false

 Usage     :	$boolean = $IN->isSecondary()
 Function  :	is this a SecondaryArticle type?
                (yes, I know this is obvious)
 Returns   :	0 (true)

package MOBY::Client::SimpleArticle;
use strict;
use Carp;
use XML::LibXML;
use MOBY::MobyXMLConstants;
use vars qw($AUTOLOAD @ISA);

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

{

	# Encapsulated:
	# DATA
	#___________________________________________________________
	#ATTRIBUTES
	my %_attr_data =    #     				DEFAULT    	ACCESSIBILITY
	  (
		articleName  => [ undef, 'read/write' ],
		objectType   => [ undef, 'read/write' ],
		objectLSID   => [ undef, 'read/write' ],
		namespaces   => [ undef, 'read/write' ],
		id           => [ undef, 'read/write' ],
		XML_DOM      => [ undef, 'read/write' ],
		XML          => [ undef, 'read/write' ],
		isSecondary  => [ 0,     'read' ],
		isSimple     => [ 1,     'read' ],
		isCollection => [ 0,     'read' ],
	  );

	#_____________________________________________________________
	# METHODS, to operate on encapsulated class data
	# Is a specified object attribute accessible in a given mode
	sub _accessible {
		my ( $self, $attr, $mode ) = @_;
		$_attr_data{$attr}[1] =~ /$mode/;
	}

	# Classwide default value for a specified object attribute
	sub _default_for {
		my ( $self, $attr ) = @_;
		$_attr_data{$attr}[0];
	}

	# List of names of all specified object attributes
	sub _standard_keys {
		keys %_attr_data;
	}

	sub addNamespace {
		my ( $self, $ns ) = @_;
		return $self->{namespaces} unless $ns;
		push @{ $self->{namespaces} }, $ns;
		return $self->{namespaces};
	}
}

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;
  foreach my $attrname ( $self->_standard_keys ) {
    if ( exists $args{$attrname} ) {
      $self->{$attrname} = $args{$attrname};
    } elsif ( $caller_is_obj ) {
      $self->{$attrname} = $caller->{$attrname};
    } else {
      $self->{$attrname} = $self->_default_for( $attrname );
    }
  }
  if ( $self->XML && ref( $self->XML ) ) {
    return 0;
  } elsif ( $self->XML_DOM && !( ref( $self->XML_DOM ) =~ /XML\:\:LibXML/ ) ) {
    return 0;
  }

  $self->createFromXML                   if ( $self->XML );
  $self->createFromDOM( $self->XML_DOM ) if ( $self->XML_DOM );
  return $self;
}

sub createFromXML {
  my ( $self ) = @_;
  my $p        = XML::LibXML->new;
  my $doc      = $p->parse_string( $self->XML );
  my $root     = $doc->getDocumentElement;
  return 0 unless ( $root && ( $root->localname eq "Simple" ) );
  return $self->createFromDOM( $root );
}

sub createFromDOM {
  my ( $self, $dom ) = @_;
  return 0 unless ( $dom && ( $dom->localname eq "Simple" ) );
  $self->XML($dom->toString);
  $self->namespaces( [] );         # reset!
  $self->articleName( "" );
  $self->objectType( "" );
  my $attr = $dom->getAttributeNode( 'articleName' );
  $attr ||= $dom->getAttributeNode( 'moby:articleName' );
  my $articleName = $attr ? $attr->getValue : "";
  $attr = $dom->getAttributeNode( 'lsid' );
  my $lsid = $attr ? $attr->getValue : "";

  $self->articleName( $articleName )
    if $articleName; # it may have already been set if this Simple is part of a Collection...
  $self->objectLSID( $lsid) if $lsid;

  # fork here - it may be an instantiated object (coming from a service invocation/response)
  # or it may be a template object as in the SimpleArticle element of a registration call
  # if the objectType tag exists, then it is a template object
  if ( @{ $dom->getElementsByLocalName( "objectType" ) }[0] ) {
    return $self->_createTemplateArticle( $dom );
  } else {
    return $self->_createInstantiatedArticle( $dom );
  }
  # otherwise it should simpy contain an instantiated MOBY object
}

sub namespace {
    my ( $self) = @_;
    my $namespaces = $self->namespaces;
    my @namespace = @{$namespaces};
    return $namespace[0] || "";
}

sub content {
    my ( $self) = @_;
    my $DOM = $self->XML_DOM;
    my $XML;
    foreach my $child ( $DOM->childNodes )
    { # there should be only one child node, and that is the data object itself; ignore whitespace
            next unless $child->nodeType == ELEMENT_NODE;
            $XML .= $child->toString;
    }
    return $XML;
}
    
sub _createInstantiatedArticle {
	my ( $self, $dom ) = @_;

	# this will take a <Simple> node from a MOBY invocation message
	# and extract the object-type and namespace from the
	# contained data object
	foreach my $child ( $dom->childNodes )
	{ # there should be only one child node, and that is the data object itself; ignore whitespace
		next unless $child->nodeType == ELEMENT_NODE;
		$self->objectType( $child->localname );
		my $attr = $child->getAttributeNode( 'namespace' );
		$attr ||= $child->getAttributeNode( 'moby:namespace' );
		$self->addNamespace( $attr->getValue ) if $attr;
		my $id = $child->getAttributeNode( 'id' );
		$id ||= $child->getAttributeNode( 'moby:id' );
		$self->id( $id->getValue ) if $id;
	}
	return $self;
}

sub _createTemplateArticle {
	my ( $self, $dom ) = @_;

	# this will take a <Simple> node from a MOBY findServiceResponse
	# message and extract the objectType and namespace array
	# from the service signature.
	my $objects = $dom->getElementsByLocalName( "objectType" );
	foreach my $child ( $objects->get_node( 1 )->getChildNodes )
	{    # there must be only one in a simple!  so take first element
		next unless $child->nodeType == TEXT_NODE;
		$self->objectType( $child->toString );
	}
	$objects = $dom->getElementsByLocalName( "Namespace" );
	foreach ( 1 .. $objects->size() ) {
		foreach my $child ( $objects->get_node( $_ )->childNodes )
		{    # there must be only one in a simple!  so take element 0
			next unless $child->nodeType == TEXT_NODE;
			next unless $child->toString;
			$self->addNamespace( $child->toString );
		}
	}
	return $self;
}

sub value {
	my ( $self ) = @_;

	# ?????  what to do here ????
}

sub AUTOLOAD {
  # It seems desirable that if the XML() method is called, the XML should be parsed, rather than just being 
  no strict "refs";
  my ( $self, $newval ) = @_;
  $AUTOLOAD =~ /.*::(\w+)/;
  my $attr = $1;
  if ( $self->_accessible( $attr, 'write' ) ) {
    *{$AUTOLOAD} = sub {
      if ( defined $_[1] ) { $_[0]->{$attr} = $_[1]; }
      return $_[0]->{$attr};
    };    ### end of created subroutine
    ###  this is called first time only
    if ( defined $newval ) {
      $self->{$attr} = $newval;
    }
    return $self->{$attr};
  } elsif ( $self->_accessible( $attr, 'read' ) ) {
    *{$AUTOLOAD} = sub {
      return $_[0]->{$attr};
    };    ### end of created subroutine
    return $self->{$attr};
  }
  
  # Must have been a mistake then...
  croak "No such method: $AUTOLOAD";
}
sub DESTROY { }
1;