docs: Update references to code symbols for hotdoc

These were done with gi-docgen in mind, but we're not going that way.

6 files changed, 37 insertions, 37 deletions

diff --git a/docs/reference/libtracker-sparql/examples.md.in b/docs/reference/libtracker-sparql/examples.md.in
index d903f20b3..b5cc86f62 100644
--- a/docs/reference/libtracker-sparql/examples.md.in
+++ b/docs/reference/libtracker-sparql/examples.md.in
@@ -10,32 +10,32 @@ SPARQL Library.
 
 ## Querying the Store
 
-First, a [class@Tracker.SparqlConnection] object must be acquired
-with [ctor@Tracker.SparqlConnection.new], [ctor@Tracker.SparqlConnection.bus_new]
-or [ctor@Tracker.SparqlConnection.remote_new].
+First, a [](TrackerSparqlConnection) object must be acquired
+with [](tracker_sparql_connection_new), [](tracker_sparql_connection_bus_new)
+or [](tracker_sparql_connection_remote_new).
 
-Then, a query can be launched either synchronously ([method@Tracker.SparqlConnection.query])
-or asynchronously ([method@Tracker.SparqlConnection.query_async]). If launched
+Then, a query can be launched either synchronously ([](tracker_sparql_connection_query))
+or asynchronously ([](tracker_sparql_connection_query_async)). If launched
 asynchronously, the results of the query can be obtained with
-[method@Tracker.SparqlConnection.query_finish].
+[](tracker_sparql_connection_query_finish).
 
-If the query was successful, a [class@Tracker.SparqlCursor]
+If the query was successful, a [](TrackerSparqlCursor)
 will be available. You can now iterate the results of the query both
-synchronously (with [method@Tracker.SparqlCursor.next]) or asynchronously
-(with [method@Tracker.SparqlCursor.next_async] and
-[method@Tracker.SparqlCursor.next_finish]).
+synchronously (with [](tracker_sparql_cursor_next)) or asynchronously
+(with [](tracker_sparql_cursor_next_async) and
+[](tracker_sparql_cursor_next_finish)).
 
-The [method@Tracker.SparqlConnection.query_statement] function can be used
-to obtain a [class@Tracker.SparqlStatement] object holding a prepared SPARQL
-query that can then be executed with [method@Tracker.SparqlStatement.execute].
+The [](tracker_sparql_connection_query_statement) function can be used
+to obtain a [](TrackerSparqlStatement) object holding a prepared SPARQL
+query that can then be executed with [](tracker_sparql_statement_execute).
 The query string can contain `~name` placeholders which can be replaced with
 arbitrary values before query execution with
-[method@Tracker.SparqlStatement.bind_string] and similar functions.
+[](tracker_sparql_statement_bind_string) and similar functions.
 This allows parsing the query string only once and to execute it multiple
 times with different parameters with potentially significant performance gains.
 
-Once you end up with the query, remember to call [method@Tracker.SparqlCursor.close].
-The same applies to [method@Tracker.SparqlConnection.close] when no longer needed.
+Once you end up with the query, remember to call [](tracker_sparql_cursor_close).
+The same applies to [](tracker_sparql_connection_close) when no longer needed.
 
 The following program shows how Read-Only queries can be done to the store in a
 synchronous way:
@@ -47,17 +47,17 @@ synchronous way:
 ## Updating the store
 
 In order to perform updates in the store, a new writable
-[class@Tracker.SparqlConnection] object must be acquired with
-[ctor@Tracker.SparqlConnection.new].
+[](TrackerSparqlConnection) object must be acquired with
+[](tracker_sparql_connection_new).
 
 Once a proper connection object has been acquired, the update can
-be launched either synchronously ([method@Tracker.SparqlConnection.update])
-or asynchronously ([method@Tracker.SparqlConnection.update_async]).
+be launched either synchronously ([](tracker_sparql_connection_update))
+or asynchronously ([](tracker_sparql_connection_update_async)).
 If launched asynchronously, the result of the operation can be obtained with
-[method@Tracker.SparqlConnection.update_finish].
+[](tracker_sparql_connection_update_finish).
 
 Once you no longer need the connection, remember to call
-[method@Tracker.SparqlConnection.close] on the [class@Tracker.SparqlConnection].
+[](tracker_sparql_connection_close) on the [](TrackerSparqlConnection).
 
 The following program shows how a synchronous update can be done to the store:
 
@@ -73,10 +73,10 @@ The majority of the work here is already described in the
 The difference with this example is that sometimes you want to
 insert data and have the URNs returned which were created to
 avoid re-querying for them. This is done using
-the [method@Tracker.SparqlConnection.update_blank] function (or asynchronously with
-[method@Tracker.SparqlConnection.update_blank_async]).
+the [](tracker_sparql_connection_update_blank) function (or asynchronously with
+[](tracker_sparql_connection_update_blank_async)).
 If launched asynchronously, the result of the operation can be obtained with
-[method@Tracker.SparqlConnection.update_blank_finish]
+[](tracker_sparql_connection_update_blank_finish)]
 
 The `_:foo` in the example is how a blank node is
 represented in SPARQL. The `foo` part is used to generate the
diff --git a/docs/reference/libtracker-sparql/limits.md b/docs/reference/libtracker-sparql/limits.md
index 4bcb19677..120b1c7c4 100644
--- a/docs/reference/libtracker-sparql/limits.md
+++ b/docs/reference/libtracker-sparql/limits.md
@@ -60,7 +60,7 @@ SQLite has a limit on the number of databases that can be attached,
 defined by `SQLITE_MAX_LIMIT_ATTACHED` (defaults to 10, maximum 128).
 
 Tracker uses attached databases to implement its support for multiple
-graphs, so the maximum amount of graphs for a given [class@Tracker.SparqlConnection]
+graphs, so the maximum amount of graphs for a given [](TrackerSparqlConnection)
 is equally restricted.
 
 ## Limits on glob search
@@ -73,7 +73,7 @@ SPARQL syntax.
 
 SQLite defines a maximum of 999 parameters to be passed as arguments
 to a statement, controlled by `SQLITE_MAX_VARIABLE_NUMBER`.
-[class@Tracker.SparqlStatement] has the same limit.
+[](TrackerSparqlStatement) has the same limit.
 
 ## Maximum number of pages in a database
 
diff --git a/docs/reference/libtracker-sparql/migrating-2to3.md b/docs/reference/libtracker-sparql/migrating-2to3.md
index 2c7e2f2e1..2330e88e6 100644
--- a/docs/reference/libtracker-sparql/migrating-2to3.md
+++ b/docs/reference/libtracker-sparql/migrating-2to3.md
@@ -110,7 +110,7 @@ those elements in place. Other ontologies might have similar concepts.
 
 Notifiers are now created through tracker_sparql_connection_create_notifier().
 
-## Different signature of [signal@Tracker.Notifier::events] signal
+## Different signature of [](TrackerNotifier::events) signal
 
 A TrackerNotifier may hint changes across multiple endpoints (local or remote),
 in consequence the signal additionally contains 2 string arguments, notifying
diff --git a/docs/reference/libtracker-sparql/overview.md b/docs/reference/libtracker-sparql/overview.md
index 0ae0d342b..c14769342 100644
--- a/docs/reference/libtracker-sparql/overview.md
+++ b/docs/reference/libtracker-sparql/overview.md
@@ -12,13 +12,13 @@ and can also store and publish any kind of app data.
 
 Querying data is done using the SPARQL graph query language. See the
 [examples](examples.html) to find out how this works.
-Storing data can also be done using SPARQL, or using the [class@Tracker.Resource]
+Storing data can also be done using SPARQL, or using the [](TrackerResource)
 API.
 
-You can share a database over D-Bus using the [class@Tracker.Endpoint] API,
+You can share a database over D-Bus using the [](TrackerEndpoint) API,
 allowing other libtracker-sparql users to query from it, either
 by referencing it in a `SELECT { SERVICE ... }` query, or by connecting
-directly with [ctor@Tracker.SparqlConnection.bus_new].
+directly with [](tracker_sparql_connection_bus_new).
 
 Tracker SPARQL partitions the database into multiple graphs.
 You can implementing access control restrictions based on
@@ -28,14 +28,14 @@ The number of graphs is [limited](limits.html).
 ## Connection methods
 
 You can create and access a private store using
-[ctor@Tracker.SparqlConnection.new]. This is useful to store
+[](tracker_sparql_connection_new). This is useful to store
 app-specific data.
 
 To connect to another database on the same local machine, such as the
-one exposed by Tracker Miner FS, use [ctor@Tracker.SparqlConnection.bus_new].
+one exposed by Tracker Miner FS, use [](tracker_sparql_connection_bus_new).
 
 To connect to another a database on a remote machine, use
-[ctor@Tracker.SparqlConnection.remote_new]. This can be used to query online
+[](tracker_sparql_connection_remote_new). This can be used to query online
 databases that provide a SPARQL endpoint, such as [DBpedia](https://wiki.dbpedia.org/about).
         .
 ## Connecting from Flatpak
@@ -48,7 +48,7 @@ The app's Flatpak manifest needs to specify which graph(s) the app will
 access. See the [example app](https://gitlab.gnome.org/GNOME/tracker/-/blob/master/examples/flatpak/org.example.TrackerSandbox.json)
 and the [portal documentation](https://gnome.pages.gitlab.gnome.org/tracker/docs/commandline/#tracker-xdg-portal-3) to see how.
 
-No code changes are needed in the app, as [ctor@Tracker.SparqlConnection.bus_new]
+No code changes are needed in the app, as [](tracker_sparql_connection_bus_new)
 will automatically try connect via the portal if it can't talk to the
 given D-Bus name directly.
 
diff --git a/docs/reference/libtracker-sparql/performance.md b/docs/reference/libtracker-sparql/performance.md
index 47510a65b..3994d850f 100644
--- a/docs/reference/libtracker-sparql/performance.md
+++ b/docs/reference/libtracker-sparql/performance.md
@@ -102,6 +102,6 @@ SELECT ?u { ?u fts:match "sideshow" }
 
 ## Use TrackerSparqlStatement
 
-Using [class@Tracker.SparqlStatement] allows to parse and compile
+Using [](TrackerSparqlStatement) allows to parse and compile
 a query once, and reuse it many times. Its usage
 is recommended wherever possible.
diff --git a/docs/reference/libtracker-sparql/sparql-and-tracker.md b/docs/reference/libtracker-sparql/sparql-and-tracker.md
index 8a33a965b..859985012 100644
--- a/docs/reference/libtracker-sparql/sparql-and-tracker.md
+++ b/docs/reference/libtracker-sparql/sparql-and-tracker.md
@@ -241,7 +241,7 @@ are treated as parameters at query time, so it is possible
 to prepare a query statement once and reuse it many times
 assigning different values to those parameters at query time.
 
-See [class@Tracker.SparqlStatement] documentation for more information.
+See [](TrackerSparqlStatement) documentation for more information.
 
 ## Full-text search