NAME

SYNOPSIS

        use RDFStore::Parser::SiRPAC;
        use RDFStore::NodeFactory;
        my $p=new RDFStore::Parser::SiRPAC(
                ErrorContext => 2,
                Handlers        => {
                        Init    => sub { print "INIT\n"; },
                        Final   => sub { print "FINAL\n"; },
                        Assert  => sub { print "STATEMENT - @_\n"; }
                },
                NodeFactory     => new RDFStore::NodeFactory() );

        $p->parsefile('http://www.gils.net/bsr-gils.rdfs');
        $p->parsefile('http://www.gils.net/rdf/bsr-gils.rdfs');
        $p->parsefile('/some/where/my.rdf');
        $p->parsefile('file:/some/where/my.rdf');
        $p->parse(*STDIN); #parse stream but with *blocking* Expat (see below example for n-blocking parsing using XML::Parse::ExpatNB)

        use RDFStore::Parser::SiRPAC;
        use RDFStore::NodeFactory;
        my $pstore=new RDFStore::Parser::SiRPAC(
                ErrorContext    => 2,
                Style           => 'RDFStore::Parser::Styles::RDFStore::Model',
                NodeFactory     => new RDFStore::NodeFactory(),
                style_options   =>      {
                                        persistent      =>      1,
                                        seevalues       =>      1,
                                        store_options         =>      { Name => '/tmp/test' }
                                }
        );
        my $rdfstore_model = $pstore->parsefile('http://www.gils.net/bsr-gils.rdfs');

        #using the expat no-blocking feature (generally for large XML streams) - see XML::Parse::Expat(3)
        my $rdfstore_stream_model = $pstore->parsestream(*STDIN);

DESCRIPTION

Exactly like XML::Parser(3) the behavior of the parser is controlled either by the Style entry elsewhere in this document and/or the Handlers entry elsewhere in this document options, or by the setHandlers entry elsewhere in this document method. These all provide mechanisms for RDFStore::Parser::SiRPAC to set the handlers needed by Expat. If neither Style nor Handlers are specified, then parsing just checks the RDF document syntax against the W3C RDF Raccomandation . When underlying handlers get called, they receive as their first parameter the Expat object, not the Parser object.

To see some examples about how to use it look at the sections below and in the samples and utils directory coming with this software distribution.

E.g. With RDFStore::Parser::SiRPAC you can easily write an rdfingest.pl script to do something like this:

        fetch -o - -q http://dmoz.org/rdf/content.rdf.u8.gz | \
                gunzip - | \
                sed -f dmoz.content.sed | rdfingest.pl -

METHODS

new

This is a class method, the constructor for RDFStore::Parser::SiRPAC. Options are passed as keyword value pairs. Recognized options are:

setHandlers(TYPE, HANDLER [, TYPE, HANDLER [...]])

This method registers handlers for various parser events. It overrides any previous handlers registered through the Style or Handler options or through earlier calls to setHandlers. By providing a false or undefined value as the handler, the existing handler can be unset.

This method returns a list of type, handler pairs corresponding to the input. The handlers returned are the ones that were in effect prior to the call.

See a description of the handler types in "HANDLERS".

parse(SOURCE, URIBASE [, OPT => OPT_VALUE [...]])

The SOURCE parameter should either be a string containing the whole RDF document, or it should be an open IO::Handle. The URIBASE can be specified by the user to set a base URI to use for the generation of resource URIs during parsing. If this option is omitted the parser will try to generate a prefix for generated resources using either the Source option of the constructor, the input filename or URL actually containing the input RDF. In a near future such an option could be obsoleted by use of XMLBase W3C raccomandation. Constructor options to XML::Parser::Expat given as keyword-value pairs may follow the URIBASE parameter. These override, for this call, any options or attributes passed through from the RDFStore::Parser::SiRPAC instance.

A die call is thrown if a parse error occurs. Otherwise it will return 1 or whatever is returned from the Final handler, if one is installed. In other words, what parse may return depends on the style.

e.g. the RDFStore::Parser::SiRPAC::RDFStore Style module returns an instance of RDFStore::Model

parsestring(STRING, URIBASE [, OPT => OPT_VALUE [...]])

This is just an alias for parse for backwards compatibility.

parsefile(URL_OR_FILE [, OPT => OPT_VALUE [...]])

Open URL_OR_FILE for reading, then call parse with the open handle. If URL_OR_FILE is a full qualified URL this module uses Socket(3) to actually fetch the content. The URIBASE parse() parameter is set to URL_OR_FILE.

getReificationCounter()

Return the current (latest) bNodes counter generated/managed by the parser

HANDLERS

 sub manage_bNodes {
        return $_[1]->createAnonymousResource( $_[2] ); #does really nothing...pass through
        };

 sub manage_bNodes {
        my ($expatm, $factory, $systemid) = @_;

        $systemid =~ s/^genidrdfstore/genidmyapplication/;

        return $factory->createAnonymousResource( $systemid );
        };

 my %app_uri_map = (
        'genidrdfstoreS302e313439323736363337373935353039P2233T1069672550N45' => 'http://www.asemantics.com/index.html',
        'alberto' => 'http://foaf.asemantics.com/alberto',
        'zac' => 'http://foaf.asemantics.com/zac',
        'dirkx' => 'http://foaf.asemantics.com/dirkx'
        );

 sub manage_bNodes {
        my ($expatm, $factory, $systemid) = @_;

        return $factory->createResource( $app_uri_map{$systemid} );
        };

WRITE YOUR OWN PARSER

You can either make you Perl script a parser self by embedding the needed function hooks or write a custom Style module for RDFStore::Parser::SiRPAC.

        use RDFStore::Parser::SiRPAC;
        use RDFStore::NodeFactory;
        my $p=new RDFStore::Parser::SiRPAC(
                Handlers        => {
                        Init    => sub { print "INIT\n"; },
                        Final   => sub { print "FINAL\n"; },
                        Assert  => sub { print "STATEMENT - @_\n"; }
                },
                NodeFactory     => new RDFStore::NodeFactory() );

        use RDFStore::Parser::SiRPAC;
        use RDFStore::NodeFactory;
        my $p=new RDFStore::Parser::SiRPAC( NodeFactory     => new RDFStore::NodeFactory() );
        $p->setHandlers(        Init    => sub { print "INIT\n"; },
                                Final   => sub { print "FINAL\n"; },
                                Assert  => sub { print join(",",@_),"\n"; }     );

        use RDFStore::Parser::SiRPAC;
        use RDFStore::Parser::SiRPAC::MyStyle;
        use RDFStore::NodeFactory;

        my $p=new RDFStore::Parser::SiRPAC(     Style => 'RDFStore::Parser::SiRPAC::MyStyle',
                                        NodeFactory     => new RDFStore::NodeFactory() );
        $p->parsefile('http://www.gils.net/bsr-gils.rdfs');

        package RDFStore::Parser::SiRPAC::MyStyle;

        sub Init { print "INIT\n"; };
        sub Final { print "FINAL\n"; };
        sub Assert {
                print "ASSERT: ",
                                $_[1]->subject()->toString(),
                                $_[1]->predicate()->toString(),
                                $_[1]->object()->toString(), "\n";
        };
        sub Start_XML_Literal { print "STARTAG: ",$_[1],"\n"; };
        sub Stop_XML_Literal { print "ENDTAG: ",$_[1],"\n"; };
        sub Char_XML_Literal { print "UTF8 chrs: ",$_[1],"\n"; };

        1;

BUGS

        * aboutEach

SEE ALSO

 RDFStore::Parser::SiRPAC(3), DBMS(3) and XML::Parser(3) XML::Parser::Expat(3)

 RDFStore::Model(3) RDFStore::NodeFactory(3)

 RDF Model and Syntax Specification - http://www.w3.org/TR/rdf-syntax-grammar/

 RDF Schema Specification 1.0 - http://www.w3.org/TR/rdf-schema/

 Benchmarking XML Parsers by Clark Cooper - http://www.xml.com/pub/Benchmark/article.html

 See also http://www.w3.org/RDF/Implementations/SiRPAC/SiRPAC-defects.html

 RDF::Parser(3) from http://www.pro-solutions.com

AUTHOR

        Alberto Reggiori <areggiori@webweaving.org>

        Sergey Melnik <melnik@db.stanford.edu> is the original author of the streaming version of SiRPAC in Java
        Clark Cooper is the author of the XML::Parser(3) module together with Larry Wall