/// <remarks>
/// \return A human-readble string.
/// </remarks> <short> \return A human-readble string.</short>
public static string ErrorString(Nepomuk.ErrorCode code)
{
return (string) staticInterceptor.Invoke("errorString$", "errorString(Nepomuk::ErrorCode)", typeof(string), typeof(Nepomuk.ErrorCode), code);
}
/// <remarks>
/// Used internally by Resource.
/// Converts a Variant into a literal value to be used in the RDF store.
/// Uses the language set in the current KDE session.
/// </remarks> <short> Used internally by Resource.</short>
public static List<Soprano.Node> ValuesToRDFNodes(Nepomuk.Variant arg1)
{
return (List<Soprano.Node>) staticInterceptor.Invoke("valuesToRDFNodes#", "valuesToRDFNodes(const Nepomuk::Variant&)", typeof(List<Soprano.Node>), typeof(Nepomuk.Variant), arg1);
}
/// <remarks>
/// Appends the value stored in \a v to the list in this
/// Variant. If this Variant contains a value with the same
/// simple type as \a v they are merged into a list. Otherwise
/// this Variant will contain one list of simple type v.simpleType()
/// </remarks> <short> Appends the value stored in \a v to the list in this Variant.</short>
public void Append(Nepomuk.Variant v)
{
interceptor.Invoke("append#", "append(const Nepomuk::Variant&)", typeof(void), typeof(Nepomuk.Variant), v);
}
/// <remarks>
/// Add a value to property 'annotation'.
/// </remarks> <short> Add a value to property 'annotation'.</short>
public void AddAnnotation(Nepomuk.Resource value)
{
interceptor.Invoke("addAnnotation#", "addAnnotation(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), value);
}
// operator QUrl(); >>>> NOT CONVERTED
/// <remarks>
/// Default copy constructor.
/// </remarks> <short> Default copy constructor.</short>
public Entity(Nepomuk.Types.Entity arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Entity#", "Entity(const Nepomuk::Types::Entity&)", typeof(void), typeof(Nepomuk.Types.Entity), arg1);
}
public Variant(Nepomuk.Resource r)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Variant#", "Variant(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), r);
}
/// <remarks>
/// Check if this property is derived from another property. This is a recursive method which
/// does not only check direct child propertyes.
/// \return true if this property is derived from other, false otherwise.
/// </remarks> <short> Check if this property is derived from another property.</short>
public bool IsSubPropertyOf(Nepomuk.Types.Property other)
{
return (bool) interceptor.Invoke("isSubPropertyOf#", "isSubPropertyOf(const Nepomuk::Types::Property&)", typeof(bool), typeof(Nepomuk.Types.Property), other);
}
/// <remarks>
/// Default copy constructor
/// </remarks> <short> Default copy constructor </short>
public Class(Nepomuk.Types.Class arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Class#", "Class(const Nepomuk::Types::Class&)", typeof(void), typeof(Nepomuk.Types.Class), arg1);
}
public Resource(Nepomuk.Resource arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Resource#", "Resource(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), arg1);
}
/// <remarks>
/// Set a property of the resource.
/// \param uri The URI identifying the property.
/// \param value The value of the property (i.e. the object of the RDF triple(s))
/// </remarks> <short> Set a property of the resource.</short>
public void SetProperty(QUrl uri, Nepomuk.Variant value)
{
interceptor.Invoke("setProperty##", "setProperty(const QUrl&, const Nepomuk::Variant&)", typeof(void), typeof(QUrl), uri, typeof(Nepomuk.Variant), value);
}
/// <remarks>
/// Add a value to property 'Topic'.
/// </remarks> <short> Add a value to property 'Topic'.</short>
public void AddTopic(Nepomuk.Resource value)
{
interceptor.Invoke("addTopic#", "addTopic(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), value);
}
/// <remarks>
/// Add a value to property 'Tag'. Each Resource can be tagged with
/// an arbitrary number of Tags. This allows a simple grouping of
/// resources.
/// </remarks> <short> Add a value to property 'Tag'.</short>
public void AddTag(Nepomuk.Tag value)
{
interceptor.Invoke("addTag#", "addTag(const Nepomuk::Tag&)", typeof(void), typeof(Nepomuk.Tag), value);
}
/// <remarks>
/// Add a value to property 'isRelated'.
/// </remarks> <short> Add a value to property 'isRelated'.</short>
public void AddIsRelated(Nepomuk.Resource value)
{
interceptor.Invoke("addIsRelated#", "addIsRelated(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), value);
}
public static Soprano.Node ValueToRDFNode(Nepomuk.Variant arg1)
{
return (Soprano.Node) staticInterceptor.Invoke("valueToRDFNode#", "valueToRDFNode(const Nepomuk::Variant&)", typeof(Soprano.Node), typeof(Nepomuk.Variant), arg1);
}
/// <remarks>
/// Retrieve a list of all resources that have property \a uri defined with a value of \a v.
/// This includes Resources that are not synced yet so it might
/// not represent exactly the state as in the RDF store.
/// \param uri The URI identifying the property. If this URI does
/// not include a namespace the default namespace is
/// prepended.
/// \param v The value all returned resources should have set as properts \a uri.
/// </remarks> <short> Retrieve a list of all resources that have property \a uri defined with a value of \a v.</short>
public List<Nepomuk.Resource> AllResourcesWithProperty(QUrl uri, Nepomuk.Variant v)
{
return (List<Nepomuk.Resource>) interceptor.Invoke("allResourcesWithProperty##", "allResourcesWithProperty(const QUrl&, const Nepomuk::Variant&)", typeof(List<Nepomuk.Resource>), typeof(QUrl), uri, typeof(Nepomuk.Variant), v);
}
/// <remarks>
/// Check if this class is derived from another class. This is a recursive method which
/// does not only check direct child classes.
/// \return true if this class is derived from other, false otherwise.
/// </remarks> <short> Check if this class is derived from another class.</short>
public bool IsSubClassOf(Nepomuk.Types.Class other)
{
return (bool) interceptor.Invoke("isSubClassOf#", "isSubClassOf(const Nepomuk::Types::Class&)", typeof(bool), typeof(Nepomuk.Types.Class), other);
}
public void SetTaggedResource(Nepomuk.Resource resource)
{
interceptor.Invoke("setTaggedResource#", "setTaggedResource(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), resource);
}
/// <remarks>
/// Copy constructor.
/// </remarks> <short> Copy constructor.</short>
public Thing(Nepomuk.Thing other)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Thing#", "Thing(const Nepomuk::Thing&)", typeof(void), typeof(Nepomuk.Thing), other);
}
/// <remarks>
/// Creates a new TagWidget for resource. The assigned tags are loaded
/// instantly.
/// </remarks> <short> Creates a new TagWidget for resource.</short>
public TagWidget(Nepomuk.Resource resource, QWidget parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("TagWidget##", "TagWidget(const Nepomuk::Resource&, QWidget*)", typeof(void), typeof(Nepomuk.Resource), resource, typeof(QWidget), parent);
}
/// <remarks>
/// Default copy constructor
/// </remarks> <short> Default copy constructor </short>
public Ontology(Nepomuk.Types.Ontology arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Ontology#", "Ontology(const Nepomuk::Types::Ontology&)", typeof(void), typeof(Nepomuk.Types.Ontology), arg1);
}
public TagWidget(Nepomuk.Resource resource)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("TagWidget#", "TagWidget(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), resource);
}
public void Append(Nepomuk.Resource r)
{
interceptor.Invoke("append#", "append(const Nepomuk::Resource&)", typeof(void), typeof(Nepomuk.Resource), r);
}
public Literal(Nepomuk.Types.Literal arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Literal#", "Literal(const Nepomuk::Types::Literal&)", typeof(void), typeof(Nepomuk.Types.Literal), arg1);
}
public Variant(Nepomuk.Variant other)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Variant#", "Variant(const Nepomuk::Variant&)", typeof(void), typeof(Nepomuk.Variant), other);
}
/// <remarks>
/// Default copy constructor
/// </remarks> <short> Default copy constructor </short>
public Tag(Nepomuk.Tag arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Tag#", "Tag(const Nepomuk::Tag&)", typeof(void), typeof(Nepomuk.Tag), arg1);
}
