1 /* 2 * Copyright (C) 2010, Nokia <ivan.frade@nokia.com> 3 * Copyright (C) 2019, Red Hat Inc. 4 * 5 * This library is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; either 8 * version 2.1 of the License, or (at your option) any later version. 9 * 10 * This library is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public 16 * License along with this library; if not, write to the 17 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 18 * Boston, MA 02110-1301, USA. 19 */ 20 #ifndef __TRACKER_PRIVATE_H__ 21 #define __TRACKER_PRIVATE_H__ 22 23 #include <libtracker-sparql/tracker-version-generated.h> 24 #include <libtracker-sparql/tracker-cursor.h> 25 #include <libtracker-sparql/tracker-endpoint-dbus.h> 26 27 typedef struct _TrackerSparqlConnectionClass TrackerSparqlConnectionClass; 28 29 struct _TrackerSparqlConnectionClass 30 { 31 GObjectClass parent_class; 32 33 TrackerSparqlCursor * (* query) (TrackerSparqlConnection *connection, 34 const gchar *sparql, 35 GCancellable *cancellable, 36 GError **error); 37 void (* query_async) (TrackerSparqlConnection *connection, 38 const gchar *sparql, 39 GCancellable *cancellable, 40 GAsyncReadyCallback callback, 41 gpointer user_data); 42 TrackerSparqlCursor * (* query_finish) (TrackerSparqlConnection *connection, 43 GAsyncResult *res, 44 GError **error); 45 void (* update) (TrackerSparqlConnection *connection, 46 const gchar *sparql, 47 GCancellable *cancellable, 48 GError **error); 49 void (* update_async) (TrackerSparqlConnection *connection, 50 const gchar *sparql, 51 GCancellable *cancellable, 52 GAsyncReadyCallback callback, 53 gpointer user_data); 54 void (* update_finish) (TrackerSparqlConnection *connection, 55 GAsyncResult *res, 56 GError **error); 57 void (* update_array_async) (TrackerSparqlConnection *connection, 58 gchar **sparql, 59 gint sparql_length, 60 GCancellable *cancellable, 61 GAsyncReadyCallback callback, 62 gpointer user_data); 63 gboolean (* update_array_finish) (TrackerSparqlConnection *connection, 64 GAsyncResult *res, 65 GError **error); 66 GVariant* (* update_blank) (TrackerSparqlConnection *connection, 67 const gchar *sparql, 68 GCancellable *cancellable, 69 GError **error); 70 void (* update_blank_async) (TrackerSparqlConnection *connection, 71 const gchar *sparql, 72 GCancellable *cancellable, 73 GAsyncReadyCallback callback, 74 gpointer user_data); 75 GVariant* (* update_blank_finish) (TrackerSparqlConnection *connection, 76 GAsyncResult *res, 77 GError **error); 78 TrackerNamespaceManager * (* get_namespace_manager) (TrackerSparqlConnection *connection); 79 TrackerSparqlStatement * (* query_statement) (TrackerSparqlConnection *connection, 80 const gchar *sparql, 81 GCancellable *cancellable, 82 GError **error); 83 TrackerNotifier * (* create_notifier) (TrackerSparqlConnection *connection); 84 85 void (* close) (TrackerSparqlConnection *connection); 86 void (* close_async) (TrackerSparqlConnection *connection, 87 GCancellable *cancellable, 88 GAsyncReadyCallback callback, 89 gpointer user_data); 90 gboolean (* close_finish) (TrackerSparqlConnection *connection, 91 GAsyncResult *res, 92 GError **error); 93 94 gboolean (* update_resource) (TrackerSparqlConnection *connection, 95 const gchar *graph, 96 TrackerResource *resource, 97 GCancellable *cancellable, 98 GError **error); 99 void (* update_resource_async) (TrackerSparqlConnection *connection, 100 const gchar *graph, 101 TrackerResource *resource, 102 GCancellable *cancellable, 103 GAsyncReadyCallback callback, 104 gpointer user_data); 105 gboolean (* update_resource_finish) (TrackerSparqlConnection *connection, 106 GAsyncResult *res, 107 GError **error); 108 TrackerBatch * (* create_batch) (TrackerSparqlConnection *connection); 109 110 gboolean (* lookup_dbus_service) (TrackerSparqlConnection *connection, 111 const gchar *dbus_name, 112 const gchar *dbus_path, 113 gchar **name, 114 gchar **path); 115 }; 116 117 typedef struct _TrackerSparqlCursorClass TrackerSparqlCursorClass; 118 119 struct _TrackerSparqlCursorClass 120 { 121 GObjectClass parent_class; 122 123 TrackerSparqlValueType (* get_value_type) (TrackerSparqlCursor *cursor, 124 gint column); 125 const gchar* (* get_variable_name) (TrackerSparqlCursor *cursor, 126 gint column); 127 const gchar* (* get_string) (TrackerSparqlCursor *cursor, 128 gint column, 129 glong *length); 130 gboolean (* next) (TrackerSparqlCursor *cursor, 131 GCancellable *cancellable, 132 GError **error); 133 void (* next_async) (TrackerSparqlCursor *cursor, 134 GCancellable *cancellable, 135 GAsyncReadyCallback callback, 136 gpointer user_data); 137 gboolean (* next_finish) (TrackerSparqlCursor *cursor, 138 GAsyncResult *res, 139 GError **error); 140 void (* rewind) (TrackerSparqlCursor* cursor); 141 void (* close) (TrackerSparqlCursor* cursor); 142 gint64 (* get_integer) (TrackerSparqlCursor *cursor, 143 gint column); 144 gdouble (* get_double) (TrackerSparqlCursor *cursor, 145 gint column); 146 gboolean (* get_boolean) (TrackerSparqlCursor *cursor, 147 gint column); 148 gboolean (* is_bound) (TrackerSparqlCursor *cursor, 149 gint column); 150 gint (* get_n_columns) (TrackerSparqlCursor *cursor); 151 }; 152 153 typedef struct _TrackerEndpointClass TrackerEndpointClass; 154 155 struct _TrackerEndpointClass { 156 GObjectClass parent_class; 157 }; 158 159 typedef struct _TrackerEndpointDBus TrackerEndpointDBus; 160 161 struct _TrackerEndpointDBus { 162 TrackerEndpoint parent_instance; 163 GDBusConnection *dbus_connection; 164 gchar *object_path; 165 guint register_id; 166 GDBusNodeInfo *node_info; 167 GCancellable *cancellable; 168 TrackerNotifier *notifier; 169 }; 170 171 typedef struct _TrackerEndpointDBusClass TrackerEndpointDBusClass; 172 173 typedef enum { 174 TRACKER_OPERATION_TYPE_SELECT, 175 TRACKER_OPERATION_TYPE_UPDATE, 176 } TrackerOperationType; 177 178 struct _TrackerEndpointDBusClass { 179 struct _TrackerEndpointClass parent_class; 180 181 gboolean (* forbid_operation) (TrackerEndpointDBus *endpoint_dbus, 182 GDBusMethodInvocation *invocation, 183 TrackerOperationType operation_type); 184 gboolean (* filter_graph) (TrackerEndpointDBus *endpoint_dbus, 185 const gchar *graph_name); 186 gchar * (* add_prologue) (TrackerEndpointDBus *endpoint_dbus); 187 }; 188 189 typedef struct _TrackerEndpointHttpClass TrackerEndpointHttpClass; 190 191 struct _TrackerEndpointHttpClass { 192 struct _TrackerEndpointClass parent_class; 193 }; 194 195 typedef struct _TrackerResourceClass TrackerResourceClass; 196 197 struct _TrackerResourceClass 198 { 199 GObjectClass parent_class; 200 }; 201 202 typedef struct _TrackerSparqlStatementClass TrackerSparqlStatementClass; 203 204 struct _TrackerSparqlStatementClass 205 { 206 GObjectClass parent_class; 207 208 void (* bind_int) (TrackerSparqlStatement *stmt, 209 const gchar *name, 210 gint64 value); 211 void (* bind_boolean) (TrackerSparqlStatement *stmt, 212 const gchar *name, 213 gboolean value); 214 void (* bind_string) (TrackerSparqlStatement *stmt, 215 const gchar *name, 216 const gchar *value); 217 void (* bind_double) (TrackerSparqlStatement *stmt, 218 const gchar *name, 219 gdouble value); 220 221 TrackerSparqlCursor * (* execute) (TrackerSparqlStatement *stmt, 222 GCancellable *cancellable, 223 GError **error); 224 void (* execute_async) (TrackerSparqlStatement *stmt, 225 GCancellable *cancellable, 226 GAsyncReadyCallback callback, 227 gpointer user_data); 228 TrackerSparqlCursor * (* execute_finish) (TrackerSparqlStatement *stmt, 229 GAsyncResult *res, 230 GError **error); 231 void (* clear_bindings) (TrackerSparqlStatement *stmt); 232 }; 233 234 typedef struct _TrackerNotifierClass TrackerNotifierClass; 235 236 struct _TrackerNotifierClass { 237 GObjectClass parent_class; 238 239 void (* events) (TrackerNotifier *notifier, 240 const GPtrArray *events); 241 }; 242 243 typedef struct _TrackerBatchClass TrackerBatchClass; 244 245 struct _TrackerBatchClass { 246 GObjectClass parent_class; 247 248 void (* add_sparql) (TrackerBatch *batch, 249 const gchar *sparql); 250 void (* add_resource) (TrackerBatch *batch, 251 const gchar *graph, 252 TrackerResource *resource); 253 gboolean (* execute) (TrackerBatch *batch, 254 GCancellable *cancellable, 255 GError **error); 256 void (* execute_async) (TrackerBatch *batch, 257 GCancellable *cancellable, 258 GAsyncReadyCallback callback, 259 gpointer user_data); 260 gboolean (* execute_finish) (TrackerBatch *batch, 261 GAsyncResult *res, 262 GError **error); 263 }; 264 265 typedef struct _TrackerSerializerClass TrackerSerializerClass; 266 267 struct _TrackerSerializerClass { 268 GInputStreamClass parent_class; 269 }; 270 271 gboolean 272 tracker_sparql_connection_lookup_dbus_service (TrackerSparqlConnection *connection, 273 const gchar *dbus_name, 274 const gchar *dbus_path, 275 gchar **name, 276 gchar **path); 277 void tracker_sparql_cursor_set_connection (TrackerSparqlCursor *cursor, 278 TrackerSparqlConnection *connection); 279 GError * _translate_internal_error (GError *error); 280 281 #endif /* __TRACKER_PRIVATE_H__ */ 282