RDF::Trine::Serializer - RDF Serializer class

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

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

       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.

perl v5.38.2                                       2024-01-13                        RDF::Trine::Serializer(3pm)

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

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

       RDF::Trine::Serializer - RDF Serializer class

        use RDF::Trine::Serializer;

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