KDE 4.3 API Reference soprano
Soprano::Server::ServerCore Class Reference
Central Soprano server class. More...
#include <Soprano/Server/ServerCore>
Public Member Functions | |
| virtual QStringList | allModels () const |
| const Backend * | backend () const |
| QList< BackendSetting > | backendSettings () const |
| bool | listen (quint16 port=DEFAULT_PORT) |
| virtual Model * | model (const QString &name) |
| void | registerAsDBusObject (const QString &objectPath=QString()) |
| virtual void | removeModel (const QString &name) |
| ServerCore (QObject *parent=0) | |
| quint16 | serverPort () const |
| void | setBackend (const Backend *backend) |
| void | setBackendSettings (const QList< BackendSetting > &settings) |
| bool | start (const QString &socketPath=QString()) |
| virtual | ~ServerCore () |
Static Public Attributes | |
| static const quint16 | DEFAULT_PORT |
Protected Member Functions | |
| virtual Model * | createModel (const QList< BackendSetting > &settings) |
Detailed Description
Central Soprano server class.The ServerCore provides a Soprano server which maintains a set of named Model instances that can be accessed by clients over a tcp connection through Server::BackendPlugin.
Creating a server is very simple: Either derive from ServerCore or create an instance and then call start() to make the server listen for incoming connections.
Soprano::Server::ServerCore core; core.start();
Optionally ServerCore can be configured using normal BackendSetting settings through setBackendSettings().
Be aware the ServerCode supports multiple ways of communication. start() opens a TCP socket to accept new connections, registerAsDBusObject() registers a DBus interface on the DBus session bus. Both ways of communication can be used simultaneously.
ServerCore is designed for single-threaded usage. Thus, model() uses Util::AsyncModel to protect against deadlocks. This behaviour can of course be changed by reimplementing model().
Definition at line 69 of file servercore.h.
Constructor & Destructor Documentation
| Soprano::Server::ServerCore::ServerCore | ( | QObject * | parent = 0 |
) |
| virtual Soprano::Server::ServerCore::~ServerCore | ( | ) | [virtual] |
Member Function Documentation
| virtual QStringList Soprano::Server::ServerCore::allModels | ( | ) | const [virtual] |
| const Backend* Soprano::Server::ServerCore::backend | ( | ) | const |
| QList<BackendSetting> Soprano::Server::ServerCore::backendSettings | ( | ) | const |
Retrieve the backend settings configured via setBackendSettings().
- Returns:
- A list of BackendSetting objects.
| virtual Model* Soprano::Server::ServerCore::createModel | ( | const QList< BackendSetting > & | settings | ) | [protected, virtual] |
Create a new Model.
The default implementation uses the configured Backend with the configured settings to create a new Model. This method can be reimplemented to create specialized Model, for example in combination with some FilterModel.
- Parameters:
-
settings The settings to use (a reimplementation may choose to ignore the settings.)
- Returns:
- A newly create Model.
| bool Soprano::Server::ServerCore::listen | ( | quint16 | port = DEFAULT_PORT |
) |
Start the Server.
Calling this method will make the Server listen on the specified port for incoming client connections.
- Parameters:
-
port The port to listen on for client connections.
- Warning:
- Via the TCP connection signals are not supported. Thus, the models created by it will not emit signals such as Model::statementAdded. Also no permission handling or any kind of security is implemented at the moment. Thus, if a server is running and is listening on a port, it is open to connections from any client on any computer in the network.
- Returns:
trueif the server was successfully started,falseotherwise.
Get or create Model with the specific name.
The default implementation will use createModel() to create a new Model if none with the specified name exists and protect it against deadlocks with a Util::AsyncModel.
- Parameters:
-
name The name of the requested Model.
Register the ServerCore as a DBus object.
The process needs to be registered as a DBus service before (QDBusConnection::registerService()).
- Parameters:
-
objectPath The DBus object path to register the server as. If empty the default path will be used (/org/soprano/Server).
In case Soprano is compiled without D-Bus support this method does nothing.
| virtual void Soprano::Server::ServerCore::removeModel | ( | const QString & | name | ) | [virtual] |
Remove a model and delete all data in it.
Use with care.
Be aware that the Model instance will also be deleted.
Should be reimplemented if model() is reimplemented.
- Parameters:
-
name The name of the requested Model.
- Warning:
- This is not the same as deleting the Model instance. It will also delete all the data on the harddisk.
| quint16 Soprano::Server::ServerCore::serverPort | ( | ) | const |
- Returns:
- The port this server is listening on or 0 if listen has not been called successfully.
- Since:
- 2.1
| void Soprano::Server::ServerCore::setBackend | ( | const Backend * | backend | ) |
| void Soprano::Server::ServerCore::setBackendSettings | ( | const QList< BackendSetting > & | settings | ) |
Set the settings that are to be used by createModel() to create new Model instances.
Be aware that Soprano::BackendOptionStorageDir will be changed to include a subdir which is the Model's name.
- Parameters:
-
settings The settings to use for new Models.
Start the core on a local socket.
On Windows this is a named pipe and on Unix this this is a local domain socket.
Use Client::LocalSocketClient to connect.
- Warning:
- Via the local socket connection signals are not supported.
- Returns:
trueif the local socket could be successfully opened.falseon error. See ErrorCache::lastError() for details.
Member Data Documentation
const quint16 Soprano::Server::ServerCore::DEFAULT_PORT [static] |
The documentation for this class was generated from the following file:
