Provided by: librdf-linkeddata-perl_0.30-1_all bug


       RDF::LinkedData::ProviderRole - Role providing important functionality for Linked Data


       Version 0.30


       See RDF::LinkedData for default usage.


       This module is now a Moose::Role. The intention with this role is threefold:

       ·   This module may run standalone, in which case the default implementation in this role
           should be sufficient for a working Linked Data server. The empty RDF::LinkedData class
           should provide such a default implementation.

       ·   This role may be implemented in classes that need to change some parts of its
           functionality, such as a mod_perl-based server.

       ·   It may be a part of a larger server framework, for example a server that supports the
           SPARQL protocol and the SPARQL RESTful protocol.

       It is not completely clear at this point what the requirements are for these three
       scenarios, but it currently satisfies the first scenario. Thus, the role may need to be
       changed substantially and possibly split into different roles based on the usage that
       evolves over time.

       Consequently, one should not rely in the current API unless you are planning to keep track
       of the development of this module. It is still very much in flux, and may change without
       warning. Just installing and using it as a Linked Data server should be OK, however, as
       its important functionality is unlikely to change in non-backwards compatible ways.


       "new ( store => $store, model => $model, base_uri => $base_uri, request => $request,
       endpoint_config => $endpoint_config )"
           Creates a new handler object based on named parameters, given a store config
           (recommended usage is to pass a hashref of the type that can be passed to
           RDF::Trine::Store->new_with_config, but a simple string can also be used) or model and
           a base URI. Optionally, you may pass a Plack::Request object (must be there if you if
           you plan to call "content") and an "endpoint_config" hashref if you want to have a
           SPARQL Endpoint running using the recommended module RDF::Endpoint.

       "endpoint ( [ $endpoint ] )"
           Returns the RDF::Endpoint object if it exists or sets it if a RDF::Endpoint object is
           given as parameter. In most cases, it will be created for you if you pass a
           "endpoint_config" hashref to the constructor, so you would most likely not use this

       "request ( [ $request ] )"
           Returns the Plack::Request object if it exists or sets it if a Plack::Request object
           is given as parameter.

       "helper_properties (  )"
           Returns the RDF::Helper::Properties object if it exists or sets it if a
           RDF::Helper::Properties object is given as parameter.

           Returns or sets the type of result to return, i.e. "page", in the case of a human-
           intended page or "data" for machine consumption, or an empty string if it is an actual
           resource URI that should be redirected.

           A node for the requested URI. This node is typically used as the subject to find which
           statements to return as data. This expects to get a URI object containing the full URI
           of the node.

       "count ( $node)"
           Returns the number of statements that has the $node as subject, or all if $node is

       "content ( $node, $type)"
           Will return the a hashref with content for this URI, based on the $node subject, and
           the type of node, which may be either "data" or "page". In the first case, an RDF
           document serialized to a format set by content negotiation. In the latter, a simple
           HTML document will be returned. The returned hashref has two keys: "content_type" and
           "body". The former is self-explanatory, the latter contains the actual content.

           One may argue that a hashref with magic keys should be a class of its own, and for
           that reason, this method should be considered "at risk". Currently, it is only used in
           one place, and it may be turned into a private method, get passed the Plack::Response
           object, removed altogether or turned into a role of its own, depending on the actual
           use cases that surfaces in the future.

           Returns or sets the RDF::Trine::Model object.

           Returns or sets the base URI for this handler.

       "response ( $uri )"
           Will look up what to do with the given URI object and populate the response object.

       namespaces ( { skos => '', dct =>
       '' } )
           Gets or sets the namespaces that some serializers use for pretty-printing.


       This module was started by by Gregory Todd Williams "<>" for
       RDF::LinkedData::Apache, but heavily refactored and rewritten by by Kjetil Kjernsmo,


       Please report any bugs or feature requests to "bug-rdf-linkeddata at", or
       through the web interface at
       <>.  I will be notified, and
       then you'll automatically be notified of progress on your bug as I make changes.


       You can find documentation for this module with the perldoc command.

           perldoc RDF::LinkedData::ProviderRole

       The perlrdf mailing list is the right place to seek help and discuss this module:




       Copyright 2010-2011 Kjetil Kjernsmo, Gregory Todd Williams and ABC Startsiden AS.

       This program is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.