package rdf

  1. Overview
  2. Docs
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Source file sioc.ml

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
(*********************************************************************************)
(*                OCaml-RDF                                                      *)
(*                                                                               *)
(*    Copyright (C) 2012-2024 Institut National de Recherche en Informatique     *)
(*    et en Automatique. All rights reserved.                                    *)
(*                                                                               *)
(*    This program is free software; you can redistribute it and/or modify       *)
(*    it under the terms of the GNU Lesser General Public License version        *)
(*    3 as published by the Free Software Foundation.                            *)
(*                                                                               *)
(*    This program is distributed in the hope that it will be useful,            *)
(*    but WITHOUT ANY WARRANTY; without even the implied warranty of             *)
(*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *)
(*    GNU General Public License for more details.                               *)
(*                                                                               *)
(*    You should have received a copy of the GNU General Public License          *)
(*    along with this program; if not, write to the Free Software                *)
(*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA                   *)
(*    02111-1307  USA                                                            *)
(*                                                                               *)
(*    Contact: Maxence.Guesdon@inria.fr                                          *)
(*                                                                               *)
(*********************************************************************************)

let sioc_str = "http://rdfs.org/sioc/ns#";;
let sioc = Iri.of_string sioc_str ;;
let sioc_ s = Iri.of_string (sioc_str ^ s);;

let c_Community = sioc_ "Community" ;;
let c_Container = sioc_ "Container" ;;
let c_Forum = sioc_ "Forum" ;;
let c_Item = sioc_ "Item" ;;
let c_Post = sioc_ "Post" ;;
let c_Role = sioc_ "Role" ;;
let c_Site = sioc_ "Site" ;;
let c_Space = sioc_ "Space" ;;
let c_Thread = sioc_ "Thread" ;;
let c_User = sioc_ "User" ;;
let c_UserAccount = sioc_ "UserAccount" ;;
let c_Usergroup = sioc_ "Usergroup" ;;
let about = sioc_ "about" ;;
let account_of = sioc_ "account_of" ;;
let addressed_to = sioc_ "addressed_to" ;;
let administrator_of = sioc_ "administrator_of" ;;
let attachment = sioc_ "attachment" ;;
let avatar = sioc_ "avatar" ;;
let container_of = sioc_ "container_of" ;;
let content = sioc_ "content" ;;
let content_encoded = sioc_ "content_encoded" ;;
let created_at = sioc_ "created_at" ;;
let creator_of = sioc_ "creator_of" ;;
let description = sioc_ "description" ;;
let email = sioc_ "email" ;;
let email_sha1 = sioc_ "email_sha1" ;;
let embeds_knowledge = sioc_ "embeds_knowledge" ;;
let feed = sioc_ "feed" ;;
let first_name = sioc_ "first_name" ;;
let follows = sioc_ "follows" ;;
let function_of = sioc_ "function_of" ;;
let group_of = sioc_ "group_of" ;;
let has_administrator = sioc_ "has_administrator" ;;
let has_container = sioc_ "has_container" ;;
let has_creator = sioc_ "has_creator" ;;
let has_discussion = sioc_ "has_discussion" ;;
let has_function = sioc_ "has_function" ;;
let has_group = sioc_ "has_group" ;;
let has_host = sioc_ "has_host" ;;
let has_member = sioc_ "has_member" ;;
let has_moderator = sioc_ "has_moderator" ;;
let has_modifier = sioc_ "has_modifier" ;;
let has_owner = sioc_ "has_owner" ;;
let has_parent = sioc_ "has_parent" ;;
let has_part = sioc_ "has_part" ;;
let has_reply = sioc_ "has_reply" ;;
let has_scope = sioc_ "has_scope" ;;
let has_space = sioc_ "has_space" ;;
let has_subscriber = sioc_ "has_subscriber" ;;
let has_usergroup = sioc_ "has_usergroup" ;;
let host_of = sioc_ "host_of" ;;
let id = sioc_ "id" ;;
let ip_address = sioc_ "ip_address" ;;
let last_activity_date = sioc_ "last_activity_date" ;;
let last_item_date = sioc_ "last_item_date" ;;
let last_name = sioc_ "last_name" ;;
let last_reply_date = sioc_ "last_reply_date" ;;
let latest_version = sioc_ "latest_version" ;;
let link = sioc_ "link" ;;
let links_to = sioc_ "links_to" ;;
let member_of = sioc_ "member_of" ;;
let moderator_of = sioc_ "moderator_of" ;;
let modified_at = sioc_ "modified_at" ;;
let modifier_of = sioc_ "modifier_of" ;;
let name = sioc_ "name" ;;
let next_by_date = sioc_ "next_by_date" ;;
let next_version = sioc_ "next_version" ;;
let note = sioc_ "note" ;;
let num_authors = sioc_ "num_authors" ;;
let num_items = sioc_ "num_items" ;;
let num_replies = sioc_ "num_replies" ;;
let num_threads = sioc_ "num_threads" ;;
let num_views = sioc_ "num_views" ;;
let owner_of = sioc_ "owner_of" ;;
let parent_of = sioc_ "parent_of" ;;
let part_of = sioc_ "part_of" ;;
let previous_by_date = sioc_ "previous_by_date" ;;
let previous_version = sioc_ "previous_version" ;;
let reference = sioc_ "reference" ;;
let related_to = sioc_ "related_to" ;;
let reply_of = sioc_ "reply_of" ;;
let scope_of = sioc_ "scope_of" ;;
let space_of = sioc_ "space_of" ;;
let subject = sioc_ "subject" ;;
let subscriber_of = sioc_ "subscriber_of" ;;
let title = sioc_ "title" ;;
let topic = sioc_ "topic" ;;
let usergroup_of = sioc_ "usergroup_of" ;;

module Open = struct
  let sioc_c_Community = c_Community
  let sioc_c_Container = c_Container
  let sioc_c_Forum = c_Forum
  let sioc_c_Item = c_Item
  let sioc_c_Post = c_Post
  let sioc_c_Role = c_Role
  let sioc_c_Site = c_Site
  let sioc_c_Space = c_Space
  let sioc_c_Thread = c_Thread
  let sioc_c_User = c_User
  let sioc_c_UserAccount = c_UserAccount
  let sioc_c_Usergroup = c_Usergroup
  let sioc_about = about
  let sioc_account_of = account_of
  let sioc_addressed_to = addressed_to
  let sioc_administrator_of = administrator_of
  let sioc_attachment = attachment
  let sioc_avatar = avatar
  let sioc_container_of = container_of
  let sioc_content = content
  let sioc_content_encoded = content_encoded
  let sioc_created_at = created_at
  let sioc_creator_of = creator_of
  let sioc_description = description
  let sioc_email = email
  let sioc_email_sha1 = email_sha1
  let sioc_embeds_knowledge = embeds_knowledge
  let sioc_feed = feed
  let sioc_first_name = first_name
  let sioc_follows = follows
  let sioc_function_of = function_of
  let sioc_group_of = group_of
  let sioc_has_administrator = has_administrator
  let sioc_has_container = has_container
  let sioc_has_creator = has_creator
  let sioc_has_discussion = has_discussion
  let sioc_has_function = has_function
  let sioc_has_group = has_group
  let sioc_has_host = has_host
  let sioc_has_member = has_member
  let sioc_has_moderator = has_moderator
  let sioc_has_modifier = has_modifier
  let sioc_has_owner = has_owner
  let sioc_has_parent = has_parent
  let sioc_has_part = has_part
  let sioc_has_reply = has_reply
  let sioc_has_scope = has_scope
  let sioc_has_space = has_space
  let sioc_has_subscriber = has_subscriber
  let sioc_has_usergroup = has_usergroup
  let sioc_host_of = host_of
  let sioc_id = id
  let sioc_ip_address = ip_address
  let sioc_last_activity_date = last_activity_date
  let sioc_last_item_date = last_item_date
  let sioc_last_name = last_name
  let sioc_last_reply_date = last_reply_date
  let sioc_latest_version = latest_version
  let sioc_link = link
  let sioc_links_to = links_to
  let sioc_member_of = member_of
  let sioc_moderator_of = moderator_of
  let sioc_modified_at = modified_at
  let sioc_modifier_of = modifier_of
  let sioc_name = name
  let sioc_next_by_date = next_by_date
  let sioc_next_version = next_version
  let sioc_note = note
  let sioc_num_authors = num_authors
  let sioc_num_items = num_items
  let sioc_num_replies = num_replies
  let sioc_num_threads = num_threads
  let sioc_num_views = num_views
  let sioc_owner_of = owner_of
  let sioc_parent_of = parent_of
  let sioc_part_of = part_of
  let sioc_previous_by_date = previous_by_date
  let sioc_previous_version = previous_version
  let sioc_reference = reference
  let sioc_related_to = related_to
  let sioc_reply_of = reply_of
  let sioc_scope_of = scope_of
  let sioc_space_of = space_of
  let sioc_subject = subject
  let sioc_subscriber_of = subscriber_of
  let sioc_title = title
  let sioc_topic = topic
  let sioc_usergroup_of = usergroup_of
end

class from ?sub g =
  let sub = match sub with None -> Term.Iri (g.Graph.name()) | Some t -> t in
  object(self)
  method about = g.Graph.objects_of ~sub ~pred: about
  method about_opt = match self#about with [] -> None | x::_ -> Some x
  method about_iris = Graph.only_iris (self#about)
  method about_opt_iri = match self#about_iris with [] -> None | x::_ -> Some x
  method account_of = g.Graph.objects_of ~sub ~pred: account_of
  method account_of_opt = match self#account_of with [] -> None | x::_ -> Some x
  method account_of_iris = Graph.only_iris (self#account_of)
  method account_of_opt_iri = match self#account_of_iris with [] -> None | x::_ -> Some x
  method addressed_to = g.Graph.objects_of ~sub ~pred: addressed_to
  method addressed_to_opt = match self#addressed_to with [] -> None | x::_ -> Some x
  method addressed_to_iris = Graph.only_iris (self#addressed_to)
  method addressed_to_opt_iri = match self#addressed_to_iris with [] -> None | x::_ -> Some x
  method administrator_of = g.Graph.objects_of ~sub ~pred: administrator_of
  method administrator_of_opt = match self#administrator_of with [] -> None | x::_ -> Some x
  method administrator_of_iris = Graph.only_iris (self#administrator_of)
  method administrator_of_opt_iri = match self#administrator_of_iris with [] -> None | x::_ -> Some x
  method attachment = g.Graph.objects_of ~sub ~pred: attachment
  method attachment_opt = match self#attachment with [] -> None | x::_ -> Some x
  method attachment_iris = Graph.only_iris (self#attachment)
  method attachment_opt_iri = match self#attachment_iris with [] -> None | x::_ -> Some x
  method avatar = g.Graph.objects_of ~sub ~pred: avatar
  method avatar_opt = match self#avatar with [] -> None | x::_ -> Some x
  method avatar_iris = Graph.only_iris (self#avatar)
  method avatar_opt_iri = match self#avatar_iris with [] -> None | x::_ -> Some x
  method container_of = g.Graph.objects_of ~sub ~pred: container_of
  method container_of_opt = match self#container_of with [] -> None | x::_ -> Some x
  method container_of_iris = Graph.only_iris (self#container_of)
  method container_of_opt_iri = match self#container_of_iris with [] -> None | x::_ -> Some x
  method content = Graph.literal_objects_of g ~sub ~pred: content
  method content_opt = match self#content with [] -> None | x::_ -> Some x
  method content_encoded = Graph.literal_objects_of g ~sub ~pred: content_encoded
  method content_encoded_opt = match self#content_encoded with [] -> None | x::_ -> Some x
  method created_at = Graph.literal_objects_of g ~sub ~pred: created_at
  method created_at_opt = match self#created_at with [] -> None | x::_ -> Some x
  method creator_of = g.Graph.objects_of ~sub ~pred: creator_of
  method creator_of_opt = match self#creator_of with [] -> None | x::_ -> Some x
  method creator_of_iris = Graph.only_iris (self#creator_of)
  method creator_of_opt_iri = match self#creator_of_iris with [] -> None | x::_ -> Some x
  method description = Graph.literal_objects_of g ~sub ~pred: description
  method description_opt = match self#description with [] -> None | x::_ -> Some x
  method email = g.Graph.objects_of ~sub ~pred: email
  method email_opt = match self#email with [] -> None | x::_ -> Some x
  method email_iris = Graph.only_iris (self#email)
  method email_opt_iri = match self#email_iris with [] -> None | x::_ -> Some x
  method email_sha1 = Graph.literal_objects_of g ~sub ~pred: email_sha1
  method email_sha1_opt = match self#email_sha1 with [] -> None | x::_ -> Some x
  method embeds_knowledge = g.Graph.objects_of ~sub ~pred: embeds_knowledge
  method embeds_knowledge_opt = match self#embeds_knowledge with [] -> None | x::_ -> Some x
  method embeds_knowledge_iris = Graph.only_iris (self#embeds_knowledge)
  method embeds_knowledge_opt_iri = match self#embeds_knowledge_iris with [] -> None | x::_ -> Some x
  method feed = g.Graph.objects_of ~sub ~pred: feed
  method feed_opt = match self#feed with [] -> None | x::_ -> Some x
  method feed_iris = Graph.only_iris (self#feed)
  method feed_opt_iri = match self#feed_iris with [] -> None | x::_ -> Some x
  method first_name = Graph.literal_objects_of g ~sub ~pred: first_name
  method first_name_opt = match self#first_name with [] -> None | x::_ -> Some x
  method follows = g.Graph.objects_of ~sub ~pred: follows
  method follows_opt = match self#follows with [] -> None | x::_ -> Some x
  method follows_iris = Graph.only_iris (self#follows)
  method follows_opt_iri = match self#follows_iris with [] -> None | x::_ -> Some x
  method function_of = g.Graph.objects_of ~sub ~pred: function_of
  method function_of_opt = match self#function_of with [] -> None | x::_ -> Some x
  method function_of_iris = Graph.only_iris (self#function_of)
  method function_of_opt_iri = match self#function_of_iris with [] -> None | x::_ -> Some x
  method group_of = g.Graph.objects_of ~sub ~pred: group_of
  method group_of_opt = match self#group_of with [] -> None | x::_ -> Some x
  method group_of_iris = Graph.only_iris (self#group_of)
  method group_of_opt_iri = match self#group_of_iris with [] -> None | x::_ -> Some x
  method has_administrator = g.Graph.objects_of ~sub ~pred: has_administrator
  method has_administrator_opt = match self#has_administrator with [] -> None | x::_ -> Some x
  method has_administrator_iris = Graph.only_iris (self#has_administrator)
  method has_administrator_opt_iri = match self#has_administrator_iris with [] -> None | x::_ -> Some x
  method has_container = g.Graph.objects_of ~sub ~pred: has_container
  method has_container_opt = match self#has_container with [] -> None | x::_ -> Some x
  method has_container_iris = Graph.only_iris (self#has_container)
  method has_container_opt_iri = match self#has_container_iris with [] -> None | x::_ -> Some x
  method has_creator = g.Graph.objects_of ~sub ~pred: has_creator
  method has_creator_opt = match self#has_creator with [] -> None | x::_ -> Some x
  method has_creator_iris = Graph.only_iris (self#has_creator)
  method has_creator_opt_iri = match self#has_creator_iris with [] -> None | x::_ -> Some x
  method has_discussion = g.Graph.objects_of ~sub ~pred: has_discussion
  method has_discussion_opt = match self#has_discussion with [] -> None | x::_ -> Some x
  method has_discussion_iris = Graph.only_iris (self#has_discussion)
  method has_discussion_opt_iri = match self#has_discussion_iris with [] -> None | x::_ -> Some x
  method has_function = g.Graph.objects_of ~sub ~pred: has_function
  method has_function_opt = match self#has_function with [] -> None | x::_ -> Some x
  method has_function_iris = Graph.only_iris (self#has_function)
  method has_function_opt_iri = match self#has_function_iris with [] -> None | x::_ -> Some x
  method has_group = g.Graph.objects_of ~sub ~pred: has_group
  method has_group_opt = match self#has_group with [] -> None | x::_ -> Some x
  method has_group_iris = Graph.only_iris (self#has_group)
  method has_group_opt_iri = match self#has_group_iris with [] -> None | x::_ -> Some x
  method has_host = g.Graph.objects_of ~sub ~pred: has_host
  method has_host_opt = match self#has_host with [] -> None | x::_ -> Some x
  method has_host_iris = Graph.only_iris (self#has_host)
  method has_host_opt_iri = match self#has_host_iris with [] -> None | x::_ -> Some x
  method has_member = g.Graph.objects_of ~sub ~pred: has_member
  method has_member_opt = match self#has_member with [] -> None | x::_ -> Some x
  method has_member_iris = Graph.only_iris (self#has_member)
  method has_member_opt_iri = match self#has_member_iris with [] -> None | x::_ -> Some x
  method has_moderator = g.Graph.objects_of ~sub ~pred: has_moderator
  method has_moderator_opt = match self#has_moderator with [] -> None | x::_ -> Some x
  method has_moderator_iris = Graph.only_iris (self#has_moderator)
  method has_moderator_opt_iri = match self#has_moderator_iris with [] -> None | x::_ -> Some x
  method has_modifier = g.Graph.objects_of ~sub ~pred: has_modifier
  method has_modifier_opt = match self#has_modifier with [] -> None | x::_ -> Some x
  method has_modifier_iris = Graph.only_iris (self#has_modifier)
  method has_modifier_opt_iri = match self#has_modifier_iris with [] -> None | x::_ -> Some x
  method has_owner = g.Graph.objects_of ~sub ~pred: has_owner
  method has_owner_opt = match self#has_owner with [] -> None | x::_ -> Some x
  method has_owner_iris = Graph.only_iris (self#has_owner)
  method has_owner_opt_iri = match self#has_owner_iris with [] -> None | x::_ -> Some x
  method has_parent = g.Graph.objects_of ~sub ~pred: has_parent
  method has_parent_opt = match self#has_parent with [] -> None | x::_ -> Some x
  method has_parent_iris = Graph.only_iris (self#has_parent)
  method has_parent_opt_iri = match self#has_parent_iris with [] -> None | x::_ -> Some x
  method has_part = g.Graph.objects_of ~sub ~pred: has_part
  method has_part_opt = match self#has_part with [] -> None | x::_ -> Some x
  method has_part_iris = Graph.only_iris (self#has_part)
  method has_part_opt_iri = match self#has_part_iris with [] -> None | x::_ -> Some x
  method has_reply = g.Graph.objects_of ~sub ~pred: has_reply
  method has_reply_opt = match self#has_reply with [] -> None | x::_ -> Some x
  method has_reply_iris = Graph.only_iris (self#has_reply)
  method has_reply_opt_iri = match self#has_reply_iris with [] -> None | x::_ -> Some x
  method has_scope = g.Graph.objects_of ~sub ~pred: has_scope
  method has_scope_opt = match self#has_scope with [] -> None | x::_ -> Some x
  method has_scope_iris = Graph.only_iris (self#has_scope)
  method has_scope_opt_iri = match self#has_scope_iris with [] -> None | x::_ -> Some x
  method has_space = g.Graph.objects_of ~sub ~pred: has_space
  method has_space_opt = match self#has_space with [] -> None | x::_ -> Some x
  method has_space_iris = Graph.only_iris (self#has_space)
  method has_space_opt_iri = match self#has_space_iris with [] -> None | x::_ -> Some x
  method has_subscriber = g.Graph.objects_of ~sub ~pred: has_subscriber
  method has_subscriber_opt = match self#has_subscriber with [] -> None | x::_ -> Some x
  method has_subscriber_iris = Graph.only_iris (self#has_subscriber)
  method has_subscriber_opt_iri = match self#has_subscriber_iris with [] -> None | x::_ -> Some x
  method has_usergroup = g.Graph.objects_of ~sub ~pred: has_usergroup
  method has_usergroup_opt = match self#has_usergroup with [] -> None | x::_ -> Some x
  method has_usergroup_iris = Graph.only_iris (self#has_usergroup)
  method has_usergroup_opt_iri = match self#has_usergroup_iris with [] -> None | x::_ -> Some x
  method host_of = g.Graph.objects_of ~sub ~pred: host_of
  method host_of_opt = match self#host_of with [] -> None | x::_ -> Some x
  method host_of_iris = Graph.only_iris (self#host_of)
  method host_of_opt_iri = match self#host_of_iris with [] -> None | x::_ -> Some x
  method id = Graph.literal_objects_of g ~sub ~pred: id
  method id_opt = match self#id with [] -> None | x::_ -> Some x
  method ip_address = Graph.literal_objects_of g ~sub ~pred: ip_address
  method ip_address_opt = match self#ip_address with [] -> None | x::_ -> Some x
  method last_activity_date = Graph.literal_objects_of g ~sub ~pred: last_activity_date
  method last_activity_date_opt = match self#last_activity_date with [] -> None | x::_ -> Some x
  method last_item_date = Graph.literal_objects_of g ~sub ~pred: last_item_date
  method last_item_date_opt = match self#last_item_date with [] -> None | x::_ -> Some x
  method last_name = Graph.literal_objects_of g ~sub ~pred: last_name
  method last_name_opt = match self#last_name with [] -> None | x::_ -> Some x
  method last_reply_date = Graph.literal_objects_of g ~sub ~pred: last_reply_date
  method last_reply_date_opt = match self#last_reply_date with [] -> None | x::_ -> Some x
  method latest_version = g.Graph.objects_of ~sub ~pred: latest_version
  method latest_version_opt = match self#latest_version with [] -> None | x::_ -> Some x
  method latest_version_iris = Graph.only_iris (self#latest_version)
  method latest_version_opt_iri = match self#latest_version_iris with [] -> None | x::_ -> Some x
  method link = g.Graph.objects_of ~sub ~pred: link
  method link_opt = match self#link with [] -> None | x::_ -> Some x
  method link_iris = Graph.only_iris (self#link)
  method link_opt_iri = match self#link_iris with [] -> None | x::_ -> Some x
  method links_to = g.Graph.objects_of ~sub ~pred: links_to
  method links_to_opt = match self#links_to with [] -> None | x::_ -> Some x
  method links_to_iris = Graph.only_iris (self#links_to)
  method links_to_opt_iri = match self#links_to_iris with [] -> None | x::_ -> Some x
  method member_of = g.Graph.objects_of ~sub ~pred: member_of
  method member_of_opt = match self#member_of with [] -> None | x::_ -> Some x
  method member_of_iris = Graph.only_iris (self#member_of)
  method member_of_opt_iri = match self#member_of_iris with [] -> None | x::_ -> Some x
  method moderator_of = g.Graph.objects_of ~sub ~pred: moderator_of
  method moderator_of_opt = match self#moderator_of with [] -> None | x::_ -> Some x
  method moderator_of_iris = Graph.only_iris (self#moderator_of)
  method moderator_of_opt_iri = match self#moderator_of_iris with [] -> None | x::_ -> Some x
  method modified_at = Graph.literal_objects_of g ~sub ~pred: modified_at
  method modified_at_opt = match self#modified_at with [] -> None | x::_ -> Some x
  method modifier_of = g.Graph.objects_of ~sub ~pred: modifier_of
  method modifier_of_opt = match self#modifier_of with [] -> None | x::_ -> Some x
  method modifier_of_iris = Graph.only_iris (self#modifier_of)
  method modifier_of_opt_iri = match self#modifier_of_iris with [] -> None | x::_ -> Some x
  method name = Graph.literal_objects_of g ~sub ~pred: name
  method name_opt = match self#name with [] -> None | x::_ -> Some x
  method next_by_date = g.Graph.objects_of ~sub ~pred: next_by_date
  method next_by_date_opt = match self#next_by_date with [] -> None | x::_ -> Some x
  method next_by_date_iris = Graph.only_iris (self#next_by_date)
  method next_by_date_opt_iri = match self#next_by_date_iris with [] -> None | x::_ -> Some x
  method next_version = g.Graph.objects_of ~sub ~pred: next_version
  method next_version_opt = match self#next_version with [] -> None | x::_ -> Some x
  method next_version_iris = Graph.only_iris (self#next_version)
  method next_version_opt_iri = match self#next_version_iris with [] -> None | x::_ -> Some x
  method note = Graph.literal_objects_of g ~sub ~pred: note
  method note_opt = match self#note with [] -> None | x::_ -> Some x
  method num_authors = Graph.literal_objects_of g ~sub ~pred: num_authors
  method num_authors_opt = match self#num_authors with [] -> None | x::_ -> Some x
  method num_items = Graph.literal_objects_of g ~sub ~pred: num_items
  method num_items_opt = match self#num_items with [] -> None | x::_ -> Some x
  method num_replies = Graph.literal_objects_of g ~sub ~pred: num_replies
  method num_replies_opt = match self#num_replies with [] -> None | x::_ -> Some x
  method num_threads = Graph.literal_objects_of g ~sub ~pred: num_threads
  method num_threads_opt = match self#num_threads with [] -> None | x::_ -> Some x
  method num_views = Graph.literal_objects_of g ~sub ~pred: num_views
  method num_views_opt = match self#num_views with [] -> None | x::_ -> Some x
  method owner_of = g.Graph.objects_of ~sub ~pred: owner_of
  method owner_of_opt = match self#owner_of with [] -> None | x::_ -> Some x
  method owner_of_iris = Graph.only_iris (self#owner_of)
  method owner_of_opt_iri = match self#owner_of_iris with [] -> None | x::_ -> Some x
  method parent_of = g.Graph.objects_of ~sub ~pred: parent_of
  method parent_of_opt = match self#parent_of with [] -> None | x::_ -> Some x
  method parent_of_iris = Graph.only_iris (self#parent_of)
  method parent_of_opt_iri = match self#parent_of_iris with [] -> None | x::_ -> Some x
  method part_of = g.Graph.objects_of ~sub ~pred: part_of
  method part_of_opt = match self#part_of with [] -> None | x::_ -> Some x
  method part_of_iris = Graph.only_iris (self#part_of)
  method part_of_opt_iri = match self#part_of_iris with [] -> None | x::_ -> Some x
  method previous_by_date = g.Graph.objects_of ~sub ~pred: previous_by_date
  method previous_by_date_opt = match self#previous_by_date with [] -> None | x::_ -> Some x
  method previous_by_date_iris = Graph.only_iris (self#previous_by_date)
  method previous_by_date_opt_iri = match self#previous_by_date_iris with [] -> None | x::_ -> Some x
  method previous_version = g.Graph.objects_of ~sub ~pred: previous_version
  method previous_version_opt = match self#previous_version with [] -> None | x::_ -> Some x
  method previous_version_iris = Graph.only_iris (self#previous_version)
  method previous_version_opt_iri = match self#previous_version_iris with [] -> None | x::_ -> Some x
  method reference = g.Graph.objects_of ~sub ~pred: reference
  method reference_opt = match self#reference with [] -> None | x::_ -> Some x
  method reference_iris = Graph.only_iris (self#reference)
  method reference_opt_iri = match self#reference_iris with [] -> None | x::_ -> Some x
  method related_to = g.Graph.objects_of ~sub ~pred: related_to
  method related_to_opt = match self#related_to with [] -> None | x::_ -> Some x
  method related_to_iris = Graph.only_iris (self#related_to)
  method related_to_opt_iri = match self#related_to_iris with [] -> None | x::_ -> Some x
  method reply_of = g.Graph.objects_of ~sub ~pred: reply_of
  method reply_of_opt = match self#reply_of with [] -> None | x::_ -> Some x
  method reply_of_iris = Graph.only_iris (self#reply_of)
  method reply_of_opt_iri = match self#reply_of_iris with [] -> None | x::_ -> Some x
  method scope_of = g.Graph.objects_of ~sub ~pred: scope_of
  method scope_of_opt = match self#scope_of with [] -> None | x::_ -> Some x
  method scope_of_iris = Graph.only_iris (self#scope_of)
  method scope_of_opt_iri = match self#scope_of_iris with [] -> None | x::_ -> Some x
  method space_of = g.Graph.objects_of ~sub ~pred: space_of
  method space_of_opt = match self#space_of with [] -> None | x::_ -> Some x
  method space_of_iris = Graph.only_iris (self#space_of)
  method space_of_opt_iri = match self#space_of_iris with [] -> None | x::_ -> Some x
  method subject = Graph.literal_objects_of g ~sub ~pred: subject
  method subject_opt = match self#subject with [] -> None | x::_ -> Some x
  method subscriber_of = g.Graph.objects_of ~sub ~pred: subscriber_of
  method subscriber_of_opt = match self#subscriber_of with [] -> None | x::_ -> Some x
  method subscriber_of_iris = Graph.only_iris (self#subscriber_of)
  method subscriber_of_opt_iri = match self#subscriber_of_iris with [] -> None | x::_ -> Some x
  method title = Graph.literal_objects_of g ~sub ~pred: title
  method title_opt = match self#title with [] -> None | x::_ -> Some x
  method topic = g.Graph.objects_of ~sub ~pred: topic
  method topic_opt = match self#topic with [] -> None | x::_ -> Some x
  method topic_iris = Graph.only_iris (self#topic)
  method topic_opt_iri = match self#topic_iris with [] -> None | x::_ -> Some x
  method usergroup_of = g.Graph.objects_of ~sub ~pred: usergroup_of
  method usergroup_of_opt = match self#usergroup_of with [] -> None | x::_ -> Some x
  method usergroup_of_iris = Graph.only_iris (self#usergroup_of)
  method usergroup_of_opt_iri = match self#usergroup_of_iris with [] -> None | x::_ -> Some x
  end
OCaml

Innovation. Community. Security.