From Code to Community: Sponsoring The Perl and Raku Conference 2025 Learn more

GWILLIAMS / RDF-Trine-0.137_01 / lib / RDF / Trine.pm 

            

              
1
2
—
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
—
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
—
107
108
109
110
111
112
113
114
115
116
117
—
118
119
120
121
122
123
124
125
126
127
128
—
129
130
131
132
133
134
135
136
137
138
139
—
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
—
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
—
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

              
# RDF::Trine
# -----------------------------------------------------------------------------
=head1 NAME
RDF::Trine - An RDF Framework for Perl
=head1 VERSION
This document describes RDF::Trine version 0.137_01
=head1 SYNOPSIS
  use RDF::Trine;
=head1 DESCRIPTION
RDF::Trine provides an RDF framework with an emphasis on extensibility, API
stability, and the presence of a test suite. The package consists of several
components:
=over 4
=item * RDF::Trine::Model - RDF model providing access to a triple store.
=item * RDF::Trine::Parser - RDF parsers for various serialization formats including RDF/XML, Turtle, RDFa, and RDF/JSON.
=item * RDF::Trine::Store::Memory - An in-memory, non-persistant triple store.
=item * RDF::Trine::Store::DBI - A triple store for MySQL and SQLite, based on the Redland schema.
=item * RDF::Trine::Iterator - Iterator classes for variable bindings and RDF statements, used by RDF::Trine::Store, RDF::Trine::Model, and RDF::Query.
=item * RDF::Trine::Namespace - A convenience class for easily constructing RDF node objects from URI namespaces.
=back
=cut
package RDF::Trine;
use 5.008003;
use strict;
use warnings;
no warnings 'redefine';
use Module::Load::Conditional qw[can_load];
our ($debug, @ISA, $VERSION, @EXPORT_OK);
BEGIN {
        $debug          = 0;
        $VERSION        = '0.137_01';
         
        require Exporter;
        @ISA            = qw(Exporter);
        @EXPORT_OK      = qw(iri blank literal variable statement store UNION_GRAPH NIL_GRAPH);
         
        can_load( modules => {
                'RDF::Redland'                                  => undef,
                'RDF::Trine::Store::Redland'    => undef,
                'RDF::Trine::Parser::Redland'   => undef,
        } );
}
use constant UNION_GRAPH        => 'tag:gwilliams@cpan.org,2010-01-01:RT:ALL';
use constant NIL_GRAPH          => 'tag:gwilliams@cpan.org,2010-01-01:RT:NIL';
use Log::Log4perl qw(:easy);
Log::Log4perl->easy_init($ERROR);
use RDF::Trine::Graph;
use RDF::Trine::Parser;
use RDF::Trine::Serializer;
use RDF::Trine::Node;
use RDF::Trine::Statement;
use RDF::Trine::Namespace;
use RDF::Trine::NamespaceMap;
use RDF::Trine::Iterator;
use RDF::Trine::Store;
use RDF::Trine::Error;
use RDF::Trine::Model;
sub _uniq {
        my %seen;
        my @data;
        foreach (@_) {
                push(@data, $_) unless ($seen{ $_ }++);
        }
        return @data;
}
=head1 FUNCTIONS
=over 4
=item C<< iri ( $iri ) >>
Returns a RDF::Trine::Node::Resource object with the given IRI value.
=cut
sub iri {
        my $iri = shift;
        return RDF::Trine::Node::Resource->new( $iri );
}
=item C<< blank ( $id ) >>
Returns a RDF::Trine::Node::Blank object with the given identifier.
=cut
sub blank {
        my $id  = shift;
        return RDF::Trine::Node::Blank->new( $id );
}
=item C<< literal ( $value, $lang, $dt ) >>
Returns a RDF::Trine::Node::Literal object with the given value and optional
language/datatype.
=cut
sub literal {
        return RDF::Trine::Node::Literal->new( @_ );
}
=item C<< variable ( $name ) >>
Returns a RDF::Trine::Node::Variable object with the given variable name.
=cut
sub variable {
        my $name        = shift;
        return RDF::Trine::Node::Variable->new( $name );
}
=item C<< statement ( @nodes ) >>
Returns a RDF::Trine::Statement object with the supplied node objects.
=cut
sub statement {
        my @nodes       = @_;
        if (scalar(@nodes) == 4) {
                return RDF::Trine::Statement::Quad->new( @nodes );
        } else {
                return RDF::Trine::Statement->new( @nodes );
        }
}
=item C<< store ( $config ) >>
Returns a RDF::Trine::Store object based on the supplied configuration string.
See L<RDF::Trine::Store> for more information on store configuration strings.
=cut
sub store {
        my $config      = shift;
        return RDF::Trine::Store->new_with_string( $config );
}
1; # Magic true value required at end of module
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to
C<< <gwilliams@cpan.org> >>.
=head1 SEE ALSO
L<http://www.perlrdf.org/>
=head1 AUTHOR
Gregory Todd Williams  C<< <gwilliams@cpan.org> >>
=head1 COPYRIGHT
Copyright (c) 2006-2010 Gregory Todd Williams. This
program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut