예제 #1
0
파일: Soprano_Error.cs 프로젝트: KDE/kimono
 /// <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);
 }
예제 #2
0
 /// <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);
 }
예제 #3
0
 /// <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);
 }
예제 #4
0
 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);
 }
예제 #5
0
 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);
 }
예제 #7
0
 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);
 }
예제 #8
0
 /// <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);
 }
예제 #9
0
 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);
 }
예제 #10
0
 /// <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);
 }
예제 #11
0
 /// <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_);
 }
예제 #12
0
 /// <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);
 }
예제 #13
0
 /// <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);
 }
예제 #14
0
 /// <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);
 }
예제 #15
0
 /// <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);
 }
예제 #17
0
 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);
 }
예제 #18
0
 public NodeIterator(Soprano.NodeIterator sti)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("NodeIterator#", "NodeIterator(const Soprano::NodeIterator&)", typeof(void), typeof(Soprano.NodeIterator), sti);
 }
예제 #19
0
 /// <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);
 }
예제 #20
0
 public bool SupportsSerialization(Soprano.RdfSerialization s)
 {
     return (bool) interceptor.Invoke("supportsSerialization$", "supportsSerialization(Soprano::RdfSerialization) const", typeof(bool), typeof(Soprano.RdfSerialization), s);
 }
예제 #21
0
 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);
 }
예제 #22
0
 public abstract bool Serialize(Soprano.StatementIterator it, QTextStream stream, Soprano.RdfSerialization serialization, string userSerialization);
예제 #23
0
 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);
 }
예제 #24
0
 /// <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);
 }
예제 #25
0
 public override bool ContainsStatement(Soprano.Statement statement)
 {
     return (bool) interceptor.Invoke("containsStatement#", "containsStatement(const Soprano::Statement&) const", typeof(bool), typeof(Soprano.Statement), statement);
 }
예제 #26
0
 /// <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);
 }
예제 #27
0
 /// <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);
 }
예제 #28
0
 /// <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);
 }
예제 #29
0
 /// <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);
 }
예제 #30
0
 public Soprano.Serializer DiscoverSerializerForSerialization(Soprano.RdfSerialization serialization)
 {
     return (Soprano.Serializer) interceptor.Invoke("discoverSerializerForSerialization$", "discoverSerializerForSerialization(Soprano::RdfSerialization)", typeof(Soprano.Serializer), typeof(Soprano.RdfSerialization), serialization);
 }