RDF::Trine::Serializer - RDF Serializer class

 use RDF::Trine::Serializer;

# RDF::Trine::Serializer
# -----------------------------------------------------------------------------

package RDF::Trine::Serializer;

use strict;
use warnings;
no warnings 'redefine';

use Data::Dumper;
use HTTP::Negotiate qw(choose);

our ($VERSION);
our %serializer_names;
our %format_uris;
our %media_types;
BEGIN {
	$VERSION	= '0.135';
}

use LWP::UserAgent;

use RDF::Trine::Serializer::NQuads;
use RDF::Trine::Serializer::NTriples;
use RDF::Trine::Serializer::NTriples::Canonical;
use RDF::Trine::Serializer::RDFXML;
use RDF::Trine::Serializer::RDFJSON;
use RDF::Trine::Serializer::Turtle;

sub serializer_names {
	return keys %serializer_names;
}

sub new {
	my $class	= shift;
	my $name	= shift;
	my $key		= lc($name);
	$key		=~ s/[^-a-z]//g;
	
	if (my $class = $serializer_names{ $key }) {
		return $class->new( @_ );
	} else {
		throw RDF::Trine::Error::SerializationError -text => "No serializer known named $name";
	}
}

sub negotiate {
	my $class	= shift;
	my %options	= @_;
	my $headers	= delete $options{ 'request_headers' };
	my $restrict	= delete $options{ 'restrict' };
	my $extend	= delete $options{ 'extend' } || {};
	my %sclasses;
	if (ref($restrict) && ref($restrict) eq 'ARRAY') {
		$sclasses{ $serializer_names{$_} } = 1 for @$restrict;
	} else {
		%sclasses = reverse %serializer_names;
	}
	my @default_variants;
	while (my($type, $sclass) = each(%media_types)) {
		next unless $sclasses{$sclass};
		my $qv;
		# slightly prefer turtle as a readable format to others
		# try hard to avoid using ntriples as 'text/plain' isn't very useful for conneg
		if ($type eq 'text/turtle') {
			$qv	= 1.0;
		} elsif ($type eq 'text/plain') {
			$qv	= 0.2;
		} else {
			$qv	= 0.99;
		}
		$qv		-= 0.01 if ($type =~ m#/x-#);				# prefer non experimental media types
		$qv		-= 0.01 if ($type =~ m#^application/(?!rdf[+]xml)#);	# prefer standard rdf/xml to other application/* formats
		push(@default_variants, [$type, $qv, $type]);
	}
	
	my %custom_thunks;
	my @custom_variants;
	while (my($type,$thunk) = each(%$extend)) {
		push(@custom_variants, [$thunk, 1.0, $type]);
		$custom_thunks{ $thunk }	= [$type, $thunk];
	}
	
	# remove variants with media types that are in custom_variants from @variants
	my @variants	= grep { not exists $extend->{ $_->[2] } } @default_variants;
	push(@variants, @custom_variants);
	
	my $stype	= choose( \@variants, $headers );
	if (defined($stype) and $custom_thunks{ $stype }) {
		my $thunk	= $stype;
		my $type	= $custom_thunks{ $stype }[0];
		return ($type, $thunk);
	}
	
	if (defined($stype) and my $sclass = $media_types{ $stype }) {
		return ($stype, $sclass->new( %options ));
	} else {
		throw RDF::Trine::Error::SerializationError -text => "No appropriate serializer found for content-negotiation";
	}
}

sub media_types {
	my $self	= shift;
	my $class	= ref($self) || $self;
	my @list;
	while (my($type, $sclass) = each(%media_types)) {
		push(@list, $type) if ($sclass eq $class);
	}
	return sort @list;
}

sub serialize_model_to_string {
	my $self	= shift;
	my $model	= shift;
	my $string	= '';
	open( my $fh, '>', \$string );
	$self->serialize_model_to_file( $fh, $model );
	close($fh);
	return $string;
}

sub serialize_iterator_to_file {
	my $self	= shift;
	my $fh		= shift;
	my $iter	= shift;
	my %args	= @_;
	my $model	= RDF::Trine::Model->temporary_model;
	while (my $st = $iter->next) {
		$model->add_statement( $st );
	}
	return $self->serialize_model_to_file( $fh, $model );
}

sub serialize_iterator_to_string {
	my $self	= shift;
	my $iter	= shift;
	my $string	= '';
	open( my $fh, '>', \$string );
	$self->serialize_iterator_to_file( $fh, $iter );
	close($fh);
	return $string;
}

1;

__END__