Provided by: librdf-linkeddata-perl_1.940-1_all bug


       RDF::LinkedData - A Linked Data server implementation


       Version 1.940


       For just setting this up and get it to run, you would just use the "linked_data.psgi"
       script in this distribution. The usage of that is documented in
       Plack::App::RDF::LinkedData, with the README being a quick start guide. If you want to try
       and use this directly, you'd do stuff like:

               my $ld = RDF::LinkedData->new(store => $config->{store},
                                        endpoint_config => $config->{endpoint},
                                        base_uri => $config->{base_uri}
               $ld->namespaces($config->{namespaces}) if ($config->{namespaces});
               return $ld->response($uri)->finalize;

       See Plack::App::RDF::LinkedData for a complete example.


       This module is used to create a Linked Data server that can serve RDF data out of an
       RDF::Trine::Model. It will look up URIs in the model and do the right thing (known as the
       303 dance) and mint URLs for that, as well as perform content negotiation. Thus, you can
       concentrate on URIs for your things, and you need not be concerned about minting URLs for
       the pages to serve it. In addition, optional modules can provide other important
       functionality: Cross-origin resource sharing, VoID description, cache headers, SPARQL
       Endpoint, Triple Pattern Fragments, etc. As such, it encompasses a fair share of Semantic
       Web best practices, but possibly not in a very flexible "Big Data" manner.


       "new ( store => $store, model => $model, base_uri => $base_uri, hypermedia => 1,
       namespaces_as_vocabularies => 1, request => $request, endpoint_config => $endpoint_config,
       void_config => $void_config, writes_enabled => 0 )"
           Creates a new handler object based on the 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 a model
           and a base URI. Optionally, you may pass a Plack::Request object (which must be passed
           before you call "content") and an "endpoint_config" hashref if you want to have a
           SPARQL Endpoint running using the recommended module RDF::Endpoint.

           This module can also provide additional triples to turn the response into a hypermedia
           type. If you don't want this, set the "hypermedia" argument to false. Currently this
           entails setting the SPARQL endpoint and vocabularies used using the VoID vocabulary

           Finally, it can provide experimental Triple Pattern Fragments <http://www.hydra-
 > support.

           Read-write  support is  even  more experimental,  and  is provided  by

           Called by Moo to initialize an object.

           Called by Moo to ensure that some attributes can be left unset.

           The model that contains the entire database of linked data.  This method returns a
           RDF::Trine::Model object.

           This model contains response, it is used to build the response to one particular
           request. This method returns a RDF::Trine::Model object of a temporary model.

           Returns or sets the base URI for this handler.

           Attribute that indicates whether write operations are permitted.

           Returns or sets whether the current request is a read operation.

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

           Returns the current Etag of the model suitable for use in a HTTP header. This is a
           read-only attribute.

       "last_etag", "has_last_etag"
           Returns or sets the last Etag of so that changes to the model can be detected.

       namespaces ( $namespace_map )
           Gets or sets the namespaces that some serializers use for pretty-printing. Should be
           handed a URI::NamespaceMap object.

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

       "helper_properties (  )"
           Returns the RDF::Helper::Properties object. if it exists; or sets it if an
           RDF::Helper::Properties object is given as a 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

       "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

       "void ( [ $voidg ] )"
           Returns the RDF::Generator::Void object, if it exists; or sets it if an
           RDF::Generator::Void object is given as parameter. Like "endpoint", it will be created
           for you if you pass a "void_config" hashref to the constructor, so you would most
           likely not use this method.


       Kjetil Kjernsmo, "<>"


       Toby Inkster


       Please report any bugs using github <>


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

           perldoc RDF::LinkedData

       The perlrdf IRC channel is the right place to seek help and discuss this module:



       This module does what it is supposed to do rather well and has thus reached the 1.0
       milestone. To support a wider variety of use cases, the current module isn't flexible
       enough, so future versions will need substantial changes, but the version number is
       intended to reflect that.


       This module was started by Gregory Todd Williams "<>" for
       RDF::LinkedData::Apache, but has been almost totally rewritten.


       Copyright 2010 Gregory Todd Williams

       Copyright 2010 ABC Startsiden AS

       Copyright 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 Kjetil Kjernsmo

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