KDE 4.2 PyKDE API Reference

- KDE's Python API

# AsyncModel Class Reference

`from PyKDE4.soprano import *`

Inherits: Soprano.FilterModel → Soprano.Model → QObject
Namespace: Soprano::Util

## Detailed Description

\class AsyncModel asyncmodel.h Soprano/Server/AsyncModel

Filter model that allows to perform operations asyncroneously.

AsyncModel has two modes: AsyncModel.SingleThreaded and AsyncModel.MultiThreaded. The main purpose of the AsyncModel.SingleThreaded mode is to protect a Model against deadlocks in a single threaded situation.

AsyncModel.MultiThreaded mode provides real asyncroneous execution of Model commands.

Usage:

     AsyncResult* result = model->listStatementsAsync( s );
     connect( result, SIGNAL(resultReady(AsyncResult*)),
              this, SLOT(slotResultReady(AsyncResult*)) );

Author:
  Sebastian Trueg <trueg@kde.org>

Since:
  2.1

## Enumerations

AsyncModelMode | { SingleThreaded, MultiThreaded }

## Methods

| __init__ (self, Soprano.Model parent=0)
Soprano.Util.AsyncResult | addStatementAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | addStatementAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | addStatementsAsync (self, [Soprano.Statement] statements)
Soprano.Util.AsyncResult | containsAnyStatementAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | containsAnyStatementAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | containsStatementAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | containsStatementAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | createBlankNodeAsync (self)
Soprano.Util.AsyncResult | executeQueryAsync (self, QString query, Soprano.Query.QueryLanguage language, QString userQueryLanguage=QString())
Soprano.Util.AsyncResult | isEmptyAsync (self)
Soprano.Util.AsyncResult | listContextsAsync (self)
Soprano.Util.AsyncResult | listStatementsAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | listStatementsAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | listStatementsAsync (self)
Soprano.Util.AsyncModel.AsyncModelMode | mode (self)
Soprano.Util.AsyncResult | removeAllStatementsAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | removeAllStatementsAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | removeStatementAsync (self, Soprano.Statement statement)
Soprano.Util.AsyncResult | removeStatementAsync (self, Soprano.Node subject, Soprano.Node predicate, Soprano.Node object, Soprano.Node context=Soprano.Node())
Soprano.Util.AsyncResult | removeStatementsAsync (self, [Soprano.Statement] statements)
| setMode (self, Soprano.Util.AsyncModel.AsyncModelMode mode)
Soprano.Util.AsyncResult | statementCountAsync (self)

## Method Documentation

__init__ | ( | self, |
|  | Soprano.Model | parent=0
| ) |  |  |

Create a new Model.

Parameters:

  | parent | The parent model to forward the operations to.

Soprano.Util.AsyncResult addStatementAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

Asyncroneously add the Statement to the Model.

Parameters:

  | statement | The Statement to add.

\sa addStatement

Returns:
  an AsyncResult with result type Error.ErrorCode object which will signal when the result is ready.

Soprano.Util.AsyncResult addStatementAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult addStatementsAsync | ( | self, |
|  | [Soprano.Statement] | statements
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult containsAnyStatementAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

Asyncroneously check if the model contains certain statements.

Parameters:

  | statement | A partially defined statement that serves as a pattern.

\sa containsAnyStatement

Returns:
  an AsyncResult with result type bool object which will signal when the result is ready.

Soprano.Util.AsyncResult containsAnyStatementAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult containsStatementAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

AsyncResult check if the model contains a statements.

Parameters:

  | statement | The statement in question. This has to be a valid statement, i.e. subject, predicate, and object need to be defined. If the context node is empty the default graph is searched.

\sa containsStatement

Returns:
  an AsyncResult with result type bool object which will signal when the result is ready.

Soprano.Util.AsyncResult containsStatementAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult createBlankNodeAsync | ( |  | self ) |

Asyncroneously create a new blank node with a unique identifier.

\sa createBlankNode

Returns:
  an AsyncResult with result type Node object which will signal when the result is ready.

Soprano.Util.AsyncResult executeQueryAsync | ( | self, |
|  | QString | query,
|  | Soprano.Query.QueryLanguage | language,
|  | QString | userQueryLanguage=QString()
| ) |  |  |

Asyncroneously execute the given query over the Model.

This is a const read-only method. As such Model implementations should not support SPARQL extensions such as INSERT or UPDATE through this method. A future version of %Soprano will provide an additional API for queries that change the Model.

Parameters:

  | query | The query to evaluate.

Parameters:

  | language | The %query language used to encode query.

Parameters:

  | userQueryLanguage | If language equals Query.QueryLanguageUser userQueryLanguage defines the language to use.

\sa executeQuery

Returns:
  an AsyncResult with result type QueryResultIterator object which will signal when the result is ready.

Soprano.Util.AsyncResult isEmptyAsync | ( |  | self ) |

Asyncroneously check if the Model does contain any Statement.

\sa isEmpty

Returns:
  an AsyncResult with result type bool object which will signal when the result is ready.

Soprano.Util.AsyncResult listContextsAsync | ( |  | self ) |

Asyncroneously list all contexts in the model, i.e. all named graphs.

\sa listContexts

Returns:
  an AsyncResult with result type NodeIterator object which will signal when the result is ready.

Soprano.Util.AsyncResult listStatementsAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

Asyncroneously return an iterator over Model Statements that "partial" match the input Statement.

Parameters:

  | statement | The partial Statement to match.

\sa listStatements

Returns:
  an AsyncResult with result type StatementIterator object which will signal when the result is ready.

Soprano.Util.AsyncResult listStatementsAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult listStatementsAsync | ( |  | self ) |

Lists all statements in the Model asyncroneously.

Since:
  2.2

Soprano.Util.AsyncModel.AsyncModelMode mode | ( |  | self ) |

The mode used by this model.

\sa setMode

Since:
  2.2

Soprano.Util.AsyncResult removeAllStatementsAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

Asyncroneously remove all statements that match the partial statement. For removing one specific statement see removeStatement().

Parameters:

  | statement | A possible partially defined statement that serves as a filter for all statements that should be removed.

\sa removeAllStatements

Returns:
  an AsyncResult with result type Error.ErrorCode object which will signal when the result is ready.

Soprano.Util.AsyncResult removeAllStatementsAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult removeStatementAsync | ( | self, |
|  | Soprano.Statement | statement
| ) |  |  |

Asyncroneously remove one statement. For removing statements with wildward matching see removeAllStatementsAsync().

Parameters:

  | statement | The statement that should be removed. This has to be a valid statement.

\sa removeStatement

Returns:
  an AsyncResult with result type Error.ErrorCode object which will signal when the result is ready.

Soprano.Util.AsyncResult removeStatementAsync | ( | self, |
|  | Soprano.Node | subject,
|  | Soprano.Node | predicate,
|  | Soprano.Node | object,
|  | Soprano.Node | context=Soprano.Node()
| ) |  |  |

Since:
  2.2

Soprano.Util.AsyncResult removeStatementsAsync | ( | self, |
|  | [Soprano.Statement] | statements
| ) |  |  |

Since:
  2.2

setMode | ( | self, |
|  | Soprano.Util.AsyncModel.AsyncModelMode | mode
| ) |  |  |

Set the mode to be used. For historical reasons the default mode is SingleThreaded.

\sa mode

Since:
  2.2

Soprano.Util.AsyncResult statementCountAsync | ( |  | self ) |

Asyncroneously determine the number of statements stored in this Model.

\sa statementCount

Returns:
  an AsyncResult with result type int object which will signal when the result is ready.

## Enumeration Documentation

AsyncModelMode

The model uses a single thread. Thus, commands are executed in the same thread but no two commands will ever block each other. This is the default mode for historical reasons.

Enumerator:

  SingleThreaded |
  MultiThreaded |