/usr/include/soprano/asyncquery.h is in libsoprano-dev 2.9.4+dfsg-1.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 | /*
* This file is part of Soprano Project.
*
* Copyright (C) 2009 Sebastian Trueg <trueg@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef _SOPRANO_UTIL_ASYNC_QUERY_H_
#define _SOPRANO_UTIL_ASYNC_QUERY_H_
#include <QtCore/QObject>
#include "error.h"
#include "sopranotypes.h"
#include "soprano_export.h"
namespace Soprano {
class Statement;
class BindingSet;
class Node;
class Model;
namespace Util {
/**
* \class AsyncQuery asyncquery.h Soprano/Util/AsyncQuery
*
* \brief A wrapper around Soprano::Model which executes a query
* in a separate thread and allows to iterate the results
* asyncroneously.
*
* In contrast to AsyncModel everything is asyncroneous, not only
* the execution of the query itself, but also the iteration.
*
* For executing a query asyncroneously simply use the static executeQuery()
* method which will return a pointer to the newly created query object.
*
* AsyncQuery objects will always delete themselves once the end of
* the iterator is reached and the finished signal has been emitted.
* This also means that boolean results need to be read in a slot
* connected to the finished() signal.
*
* Typical usage would be to connect to the nextReady() signal, use one of the
* binding() methods or currentStatement() to get the current value, and then
* call next() in it to trigger async iteration to the next element:
*
* \code
* void MyQueryHandler::slotNextReady( Soprano::Util::AsyncQuery* query ) {
* // do something with the current value
* addToSomeList( query->binding(0) );
*
* // trigger async iteration to the next element
* query->next();
* }
* \endcode
*
* \sa Soprano::Util::AsyncModel
*
* \author Sebastian Trueg <trueg@kde.org>
*
* \since 2.4
*/
class SOPRANO_EXPORT AsyncQuery : public QObject, public Error::ErrorCache
{
Q_OBJECT
public:
/**
* Delete the query. This will cancel an unfinished query.
* Be aware that normally there is no need to delete the query
* object as it will auto-delete itself once finished.
*
* \sa close()
*/
~AsyncQuery();
//@{
/**
* Retrieve the current Statement after nextReady has been emitted.
* This method does only make sense for graph queries.
*/
Statement currentStatement() const;
/**
* Convenience method that puts all current bindings into one map.
* This method does only make sense for tuple queries.
*/
BindingSet currentBindings() const;
/**
* This method does only make sense for boolean queries.
*
* \return The result of a boolean query (SPARQL ASK).
*
* \sa isBool()
*/
bool boolValue() const;
//@}
//@{
/**
* Get the current binding for a variable.
*
* \param name The name of the requested variable.
*
* This method does only make sense for tuple queries.
*
* \return The binding for the requested variable or and invalid
* node if the bindings do not contain the variable.
*/
Node binding( const QString &name ) const;
/**
* Get the current binding for a variable by index.
*
* \param offset The index of the requested variable.
*
* This method does only make sense for tuple queries.
*
* \return The binding for the requested variable or and invalid
* node if offset is out of bounds, i.e. bigger or equal to bindingCount().
*/
Node binding( int offset ) const;
/**
* The number of bindings in this query result.
*
* This method does only make sense for tuple queries.
*
* \return The number of bindings.
*/
int bindingCount() const;
/**
* This method does only make sense for tuple queries.
*
* \return The names of the bound variables in this query result.
*/
QStringList bindingNames() const;
//@}
//@{
/**
* Check if this is a graph result.
*
* \return \p true if this result refers to a graph query, i.e. currentStatement()
* returns valid values.
*/
bool isGraph() const;
/**
* Check if this is a tuple result.
*
* \return \p true if this result refers to a tuple query, i.e. currentBindings(),
* binding(), bindingCount(), and bindingNames() return valid values.
*/
bool isBinding() const;
/**
* Check if this is a boolean result.
*
* There is no need to call next() for boolean results. However, for internal reasons
* backends need to always return \p true for boolean queries.
*
* \return \p true if this result refers to a boolean query (SPARQL ASK), i.e.
* boolValue() returns a valid value.
*/
bool isBool() const;
//@}
public Q_SLOTS:
/**
* Trigger iteration to the next element once the current has been read via one of
* the binding() methods or currentStatement(). Be aware that this has not to be called
* for the first element which is emitted automatically.
* Once the next result has been retrieved the nextReady signal is emitted.
*
* \return \p true if successful, \p false if the iteration reached the end.
*/
bool next();
/**
* Closes the query. This will cancel the query if it is not finished yet.
* Afterwards the query will delete itself. It has the same effect as
* deleting the query object manually.
*
* finished() will always be emitted in case the query was not finished yet.
*/
void close();
Q_SIGNALS:
/**
* Emitted once the next value is ready when iterating the result via
* next(). Will be emitted automatically for the first element.
* The last call in a connected slot should be next() to trigger
* iteration to the next element.
*
* \param query The query itself for convinience.
*/
void nextReady( Soprano::Util::AsyncQuery* query );
/**
* Emitted once the last element has been read and the internal
* iterator is finished after the last call to next() or if the result
* of a boolean query is available.
*
* Once this signals has been emitted the query will delete itself.
* In a slot connected to this signal ErrorCache::lastError() can be
* used to retrieve information about the success of the query.
*
* \param query The query itself for convinience.
*/
void finished( Soprano::Util::AsyncQuery* query );
public:
/**
* Create a new query object.
*
* \param model The model to execute the query on.
* \param query The query to evaluate.
* \param language The %query language used to encode \p query.
* \param userQueryLanguage If \p language equals Query::QueryLanguageUser
* userQueryLanguage defines the language to use.
*
* \sa Model::executeQuery
*
* \return A new AsyncQuery instance which is ready to be used or 0 if \p model
* is 0. The query will delete itself once it is finished. It can also be deleted
* at any point in time to cancel the query.
*/
static AsyncQuery* executeQuery( Soprano::Model* model,
const QString& query,
Query::QueryLanguage language,
const QString& userQueryLanguage = QString() );
private:
AsyncQuery();
class Private;
Private* const d;
Q_PRIVATE_SLOT( d, void _s_finished() )
Q_PRIVATE_SLOT( d, void _s_emitNextReady() )
};
}
}
#endif
|