/// <remarks>
/// Translate an error code into a human-readable error message.
/// </remarks> <short> Translate an error code into a human-readable error message.</short>
public static string ErrorMessage(Soprano.Error.ErrorCode arg1)
{
return (string) staticInterceptor.Invoke("errorMessage$", "errorMessage(Soprano::Error::ErrorCode)", typeof(string), typeof(Soprano.Error.ErrorCode), arg1);
}
/// <remarks>
/// Insert a new binding into the set.
/// </remarks> <short> Insert a new binding into the set.</short>
public void Insert(string name, Soprano.Node value)
{
interceptor.Invoke("insert$#", "insert(const QString&, const Soprano::Node&)", typeof(void), typeof(string), name, typeof(Soprano.Node), value);
}
/// <remarks>
/// Replaces a value in the binding set.
/// \since 2.3
/// </remarks> <short> Replaces a value in the binding set.</short>
public void Replace(string name, Soprano.Node value)
{
interceptor.Invoke("replace$#", "replace(const QString&, const Soprano::Node&)", typeof(void), typeof(string), name, typeof(Soprano.Node), value);
}
public override Soprano.Error.ErrorCode RemoveAllStatements(Soprano.Statement statement)
{
return (Soprano.Error.ErrorCode) interceptor.Invoke("removeAllStatements#", "removeAllStatements(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), statement);
}
public override Soprano.Error.ErrorCode AddStatement(Soprano.Statement statement)
{
return (Soprano.Error.ErrorCode) interceptor.Invoke("addStatement#", "addStatement(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), statement);
}
public InferenceModel(Soprano.Model parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("InferenceModel#", "InferenceModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), parent);
}
public override Soprano.QueryResultIterator ExecuteQuery(string query, Soprano.Query.QueryLanguage language)
{
return (Soprano.QueryResultIterator) interceptor.Invoke("executeQuery$$", "executeQuery(const QString&, Soprano::Query::QueryLanguage) const", typeof(Soprano.QueryResultIterator), typeof(string), query, typeof(Soprano.Query.QueryLanguage), language);
}
/// <remarks>
/// Copy constructor.
/// </remarks> <short> Copy constructor.</short>
public BackendSetting(Soprano.BackendSetting other)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("BackendSetting#", "BackendSetting(const Soprano::BackendSetting&)", typeof(void), typeof(Soprano.BackendSetting), other);
}
public Soprano.Util.AsyncResult ExecuteQueryAsync(string query, Soprano.Query.QueryLanguage language)
{
return (Soprano.Util.AsyncResult) interceptor.Invoke("executeQueryAsync$$", "executeQueryAsync(const QString&, Soprano::Query::QueryLanguage) const", typeof(Soprano.Util.AsyncResult), typeof(string), query, typeof(Soprano.Query.QueryLanguage), language);
}
/// <remarks>
/// Create a boolean setting with a default true value.
/// </remarks> <short> Create a boolean setting with a default true value.</short>
public BackendSetting(Soprano.BackendOption option)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("BackendSetting$", "BackendSetting(Soprano::BackendOption)", typeof(void), typeof(Soprano.BackendOption), option);
}
/// <remarks>
/// Create a standard setting with option <pre>s</pre> and value <pre>value_</pre>.
/// </remarks> <short> Create a standard setting with option \p s and value \p value_.</short>
public BackendSetting(Soprano.BackendOption s, QVariant value_)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("BackendSetting$#", "BackendSetting(Soprano::BackendOption, const QVariant&)", typeof(void), typeof(Soprano.BackendOption), s, typeof(QVariant), value_);
}
/// <remarks>
/// Default copy constructor
/// </remarks> <short> Default copy constructor </short>
public LiteralValue(Soprano.LiteralValue other)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("LiteralValue#", "LiteralValue(const Soprano::LiteralValue&)", typeof(void), typeof(Soprano.LiteralValue), other);
}
/// <remarks>
/// Set the Backend used in the Server to create Models.
/// </remarks> <short> Set the Backend used in the Server to create Models.</short>
public void SetBackend(Soprano.Backend backend)
{
interceptor.Invoke("setBackend#", "setBackend(const Soprano::Backend*)", typeof(void), typeof(Soprano.Backend), backend);
}
/// <remarks>
/// \param backend The Backend that created this model.
/// </remarks> <short> \param backend The Backend that created this model.</short>
public StorageModel(Soprano.Backend backend)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("StorageModel#", "StorageModel(const Soprano::Backend*)", typeof(void), typeof(Soprano.Backend), backend);
}
/// <remarks>
/// Create a new read-only-model
/// \param parentModel The parent Model.
/// </remarks> <short> Create a new read-only-model \param parentModel The parent Model.</short>
public ReadOnlyModel(Soprano.Model parentModel)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("ReadOnlyModel#", "ReadOnlyModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), parentModel);
}
public SimpleStatementIterator(Soprano.Util.SimpleStatementIterator arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("SimpleStatementIterator#", "SimpleStatementIterator(const Soprano::Util::SimpleStatementIterator&)", typeof(void), typeof(Soprano.Util.SimpleStatementIterator), arg1);
}
public override Soprano.Error.ErrorCode RemoveStatement(Soprano.Statement arg1)
{
return (Soprano.Error.ErrorCode) interceptor.Invoke("removeStatement#", "removeStatement(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), arg1);
}
public NodeIterator(Soprano.NodeIterator sti)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("NodeIterator#", "NodeIterator(const Soprano::NodeIterator&)", typeof(void), typeof(Soprano.NodeIterator), sti);
}
/// <remarks>
/// Add an inference rule to the set of rules.
/// This method will not trigger any inference action. If inference
/// is necessary call performInference() after adding the new rules.
/// </remarks> <short> Add an inference rule to the set of rules.</short>
public void AddRule(Soprano.Inference.Rule arg1)
{
interceptor.Invoke("addRule#", "addRule(const Soprano::Inference::Rule&)", typeof(void), typeof(Soprano.Inference.Rule), arg1);
}
public bool SupportsSerialization(Soprano.RdfSerialization s)
{
return (bool) interceptor.Invoke("supportsSerialization$", "supportsSerialization(Soprano::RdfSerialization) const", typeof(bool), typeof(Soprano.RdfSerialization), s);
}
public override Soprano.StatementIterator ListStatements(Soprano.Statement partial)
{
return (Soprano.StatementIterator) interceptor.Invoke("listStatements#", "listStatements(const Soprano::Statement&) const", typeof(Soprano.StatementIterator), typeof(Soprano.Statement), partial);
}
public abstract bool Serialize(Soprano.StatementIterator it, QTextStream stream, Soprano.RdfSerialization serialization, string userSerialization);
public MutexModel(Soprano.Util.MutexModel.ProtectionMode mode)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MutexModel$", "MutexModel(Soprano::Util::MutexModel::ProtectionMode)", typeof(void), typeof(Soprano.Util.MutexModel.ProtectionMode), mode);
}
/// <remarks>
/// Check if a plugin supports a specific serialization.
/// \param s The requested serialization.
/// \param userSerialization If serialization is set to Soprano.SerializationUser this parameter specifies the
/// requested serialization. It allows the extension of the %Soprano Serializer interface with new
/// RDF serializations that are not officially supported by %Soprano.
/// \return <pre>true</pre> if the serializer is able to parse RDF data encoded
/// in serialization s, <pre>false</pre> otherwise.
/// </remarks> <short> Check if a plugin supports a specific serialization.</short>
public bool SupportsSerialization(Soprano.RdfSerialization s, string userSerialization)
{
return (bool) interceptor.Invoke("supportsSerialization$$", "supportsSerialization(Soprano::RdfSerialization, const QString&) const", typeof(bool), typeof(Soprano.RdfSerialization), s, typeof(string), userSerialization);
}
public override bool ContainsStatement(Soprano.Statement statement)
{
return (bool) interceptor.Invoke("containsStatement#", "containsStatement(const Soprano::Statement&) const", typeof(bool), typeof(Soprano.Statement), statement);
}
/// <remarks>
/// Create a new D-Bus export model.
/// \param model The parent model which should be exported.
/// </remarks> <short> Create a new D-Bus export model.</short>
public DBusExportModel(Soprano.Model model)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("DBusExportModel#", "DBusExportModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), model);
}
/// <remarks>
/// Replaces a value in the binding set.
/// \since 2.3
/// </remarks> <short> Replaces a value in the binding set.</short>
public void Replace(int offset, Soprano.Node value)
{
interceptor.Invoke("replace$#", "replace(int, const Soprano::Node&)", typeof(void), typeof(int), offset, typeof(Soprano.Node), value);
}
/// <remarks>
/// Set the parent Model.
/// \param model The Model that this filter will forward any commands to.
/// </remarks> <short> Set the parent Model.</short>
public void SetParentModel(Soprano.Model model)
{
interceptor.Invoke("setParentModel#", "setParentModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), model);
}
/// <remarks>
/// Copy constructor.
/// </remarks> <short> Copy constructor.</short>
public BindingSet(Soprano.BindingSet other)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("BindingSet#", "BindingSet(const Soprano::BindingSet&)", typeof(void), typeof(Soprano.BindingSet), other);
}
public Soprano.Serializer DiscoverSerializerForSerialization(Soprano.RdfSerialization serialization)
{
return (Soprano.Serializer) interceptor.Invoke("discoverSerializerForSerialization$", "discoverSerializerForSerialization(Soprano::RdfSerialization)", typeof(Soprano.Serializer), typeof(Soprano.RdfSerialization), serialization);
}
