NAME

       RDF::Trine::Serializer - RDF Serializer class

VERSION

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

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 "<'extend' "> 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".

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.