NAME

       RDF::Trine::Serializer - RDF Serializer class

VERSION

       This document describes RDF::Trine::Serializer version 1.007

SYNOPSIS

        use RDF::Trine::Serializer;

DESCRIPTION

       The RDF::Trine::Serializer class provides an API for serializing RDF graphs (via both
       model objects and graph iterators) to strings and files.

METHODS

       "serializer_names"
           Returns a list of valid serializer names for use as arguments to the serializer
           constructor.

       "new ( $serializer_name, %options )"
           Returns a new RDF::Trine::Serializer object for the serializer with the specified name
           (e.g. "rdfxml" or "turtle"). If no serializer with the specified name is found, throws
           a RDF::Trine::Error::SerializationError exception.

           The valid key-values used in %options are specific to a particular serializer
           implementation. For serializers that support namespace declarations (to allow more
           concise serialization), use "namespaces => \%namespaces" in %options, where the keys
           of %namespaces are namespace names and the values are (partial) URIs. For serializers
           that support base URI declarations, use "base_uri => $base_uri" .

       "negotiate ( request_headers => $request_headers, %options )"
           Returns a two-element list containing an appropriate media type and
           RDF::Trine::Serializer object as decided by HTTP::Negotiate.  If the 'request_headers'
           key-value is supplied, the $request_headers is passed to "HTTP::Negotiate::choose".
           The option 'restrict', set to a list of serializer names, can be used to limit the
           serializers to choose from. Finally, an "<'extends' "> option can be set to a hashref
           that contains MIME-types as keys and a custom variant as value. This will enable the
           user to use this negotiator to return a type that isn't supported by any serializers.
           The subsequent code will have to find out how to return a representation. The rest of
           %options is passed through to the serializer constructor.

       "media_types"
           Returns a list of media types appropriate for the format of the serializer.

       "serialize_model_to_file ( $fh, $model )"
           Serializes the $model, printing the results to the supplied filehandle "<$fh">.

       "serialize_model_to_string ( $model )"
           Serializes the $model, returning the result as a string.

       "serialize_iterator_to_file ( $file, $iterator )"
           Serializes the statement objects produced by $iterator, printing the results to the
           supplied filehandle "<$fh">.

           Note that some serializers may not support the use of this method, or may require the
           full materialization of the iterator in order to serialize it.  If materialization is
           required, available memeory may constrain the iterators that can be serialized.

       "serialize_iterator_to_string ( $iterator )"
           Serializes the statement objects produced by $iterator, returning the result as a
           string. Note that the same constraints apply to this method as to
           "serialize_iterator_to_file".

       1;

       __END__

BUGS

       Please report any bugs or feature requests to through the GitHub web interface at
       <https://github.com/kasei/perlrdf/issues>.

AUTHOR

       Gregory Todd Williams  "<gwilliams@cpan.org>"

COPYRIGHT

       Copyright (c) 2006-2012 Gregory Todd Williams. This program is free software; you can
       redistribute it and/or modify it under the same terms as Perl itself.