forked from kasei/perlrdf
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Pattern.pm
186 lines (125 loc) · 3.22 KB
/
Pattern.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
# RDF::Trine::Pattern
# -----------------------------------------------------------------------------
=head1 NAME
RDF::Trine::Pattern - Class for basic graph patterns
=head1 VERSION
This document describes RDF::Trine::Pattern version 0.134
=cut
package RDF::Trine::Pattern;
use strict;
use warnings;
no warnings 'redefine';
use Data::Dumper;
use Log::Log4perl;
use Scalar::Util qw(blessed);
use Carp qw(carp croak confess);
use RDF::Trine::Iterator qw(smap);
######################################################################
our ($VERSION);
BEGIN {
$VERSION = '0.134';
}
######################################################################
=head1 METHODS
=over 4
=item C<< new ( @triples ) >>
Returns a new BasicGraphPattern structure.
=cut
sub new {
my $class = shift;
my @triples = @_;
foreach my $t (@triples) {
unless (blessed($t) and $t->isa('RDF::Trine::Statement')) {
throw RDF::Trine::Error -text => "Patterns belonging to a BGP must be triples";
}
}
return bless( [ @triples ] );
}
=item C<< construct_args >>
Returns a list of arguments that, passed to this class' constructor,
will produce a clone of this algebra pattern.
=cut
sub construct_args {
my $self = shift;
return ($self->triples);
}
=item C<< triples >>
Returns a list of triples belonging to this BGP.
=cut
sub triples {
my $self = shift;
return @$self;
}
=item C<< type >>
=cut
sub type {
return 'BGP';
}
=item C<< sse >>
Returns the SSE string for this algebra expression.
=cut
sub sse {
my $self = shift;
my $context = shift;
return sprintf(
'(bgp %s)',
join(' ', map { $_->sse( $context ) } $self->triples)
);
}
=item C<< referenced_variables >>
Returns a list of the variable names used in this algebra expression.
=cut
sub referenced_variables {
my $self = shift;
return RDF::Trine::_uniq(map { $_->referenced_variables } $self->triples);
}
=item C<< definite_variables >>
Returns a list of the variable names that will be bound after evaluating this algebra expression.
=cut
sub definite_variables {
my $self = shift;
return RDF::Trine::_uniq(map { $_->definite_variables } $self->triples);
}
=item C<< clone >>
=cut
sub clone {
my $self = shift;
my $class = ref($self);
return $class->new( map { $_->clone } $self->triples );
}
=item C<< bind_variables ( \%bound ) >>
Returns a new pattern with variables named in %bound replaced by their corresponding bound values.
=cut
sub bind_variables {
my $self = shift;
my $class = ref($self);
my $bound = shift;
return $class->new( map { $_->bind_variables( $bound ) } $self->triples );
}
=item C<< subsumes ( $statement ) >>
Returns true if the pattern will subsume the $statement when matched against a
triple store.
=cut
sub subsumes {
my $self = shift;
my $st = shift;
my $l = Log::Log4perl->get_logger("rdf.trine.pattern");
my @triples = $self->triples;
foreach my $t (@triples) {
if ($t->subsumes( $st )) {
$l->debug($self->sse . " \x{2292} " . $st->sse);
return 1;
}
}
return 0;
}
1;
__END__
=back
=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