kpriv/pkgsrc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pkgsrc/textproc/soprano/PLIST

183 lines
5.7 KiB
Text
Raw Normal View History

Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
@comment $NetBSD: PLIST,v 1.7 2010/04/10 00:02:03 markd Exp $
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
bin/onto2vocabularyclass
bin/sopranocmd
bin/sopranod
include/Soprano/Backend
include/Soprano/BackendFeature
include/Soprano/BackendOption
include/Soprano/BackendSetting
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/Soprano/BackendSettings
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/BindingSet
include/Soprano/Client/DBusClient
include/Soprano/Client/DBusModel
include/Soprano/Client/DBusNodeIterator
include/Soprano/Client/DBusQueryResultIterator
include/Soprano/Client/DBusStatementIterator
include/Soprano/Client/LocalSocketClient
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/Soprano/Client/SparqlModel
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/Client/TcpClient
include/Soprano/Error/Error
include/Soprano/Error/ErrorCache
include/Soprano/Error/ErrorCode
include/Soprano/Error/Locator
include/Soprano/Error/ParserError
include/Soprano/FilterModel
include/Soprano/Global
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/Soprano/Graph
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/Index/CLuceneIndex
include/Soprano/Index/IndexFilterModel
include/Soprano/Index/QueryHit
include/Soprano/Inference/InferenceModel
include/Soprano/Inference/NodePattern
include/Soprano/Inference/Rule
include/Soprano/Inference/RuleParser
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/Soprano/Inference/RuleSet
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/Inference/StandardRuleSet
include/Soprano/Inference/StatementPattern
include/Soprano/Iterator
include/Soprano/IteratorBackend
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/Soprano/LanguageTag
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/LiteralValue
include/Soprano/Model
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/Soprano/NRLModel
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/Node
include/Soprano/NodeIterator
include/Soprano/Parser
include/Soprano/Plugin
include/Soprano/PluginManager
include/Soprano/Query/QueryLanguage
include/Soprano/QueryResultIterator
include/Soprano/QueryResultIteratorBackend
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/Soprano/RdfSchemaModel
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/RdfSerialization
include/Soprano/Serializer
include/Soprano/Server/DBusExportIterator
include/Soprano/Server/DBusExportModel
include/Soprano/Server/ServerCore
include/Soprano/Soprano
include/Soprano/Statement
include/Soprano/StatementIterator
include/Soprano/StorageModel
include/Soprano/Util/AsyncModel
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
include/Soprano/Util/AsyncQuery
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/Soprano/Util/AsyncResult
include/Soprano/Util/DummyModel
include/Soprano/Util/MutexModel
include/Soprano/Util/ReadOnlyModel
include/Soprano/Util/SignalCacheModel
include/Soprano/Util/SimpleNodeIterator
include/Soprano/Util/SimpleStatementIterator
include/Soprano/Version
include/Soprano/Vocabulary/NAO
include/Soprano/Vocabulary/NRL
include/Soprano/Vocabulary/OWL
include/Soprano/Vocabulary/RDF
include/Soprano/Vocabulary/RDFS
include/Soprano/Vocabulary/SIL
include/Soprano/Vocabulary/XMLSchema
include/Soprano/Vocabulary/Xesam
include/soprano/asyncmodel.h
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
include/soprano/asyncquery.h
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/soprano/asyncresult.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/backend.h
include/soprano/bindingset.h
include/soprano/cluceneindex.h
include/soprano/dbusclient.h
include/soprano/dbusexportiterator.h
include/soprano/dbusexportmodel.h
include/soprano/dbusmodel.h
include/soprano/dbusnodeiterator.h
include/soprano/dbusqueryresultiterator.h
include/soprano/dbusstatementiterator.h
include/soprano/dummymodel.h
include/soprano/error.h
include/soprano/filtermodel.h
include/soprano/global.h
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/soprano/graph.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/indexfiltermodel.h
include/soprano/indexqueryhit.h
include/soprano/inferencemodel.h
include/soprano/inferencerule.h
include/soprano/inferenceruleparser.h
include/soprano/inferenceruleset.h
include/soprano/iterator.h
include/soprano/iteratorbackend.h
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/soprano/languagetag.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/literalvalue.h
include/soprano/localsocketclient.h
include/soprano/locator.h
include/soprano/model.h
include/soprano/mutexmodel.h
include/soprano/nao.h
include/soprano/node.h
include/soprano/nodeiterator.h
include/soprano/nodepattern.h
include/soprano/nrl.h
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/soprano/nrlmodel.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/owl.h
include/soprano/parser.h
include/soprano/plugin.h
include/soprano/pluginmanager.h
include/soprano/queryresultiterator.h
include/soprano/queryresultiteratorbackend.h
include/soprano/rdf.h
include/soprano/rdfs.h
include/soprano/rdfschemamodel.h
include/soprano/readonlymodel.h
include/soprano/serializer.h
include/soprano/servercore.h
include/soprano/signalcachemodel.h
include/soprano/sil.h
include/soprano/simplenodeiterator.h
include/soprano/simplestatementiterator.h
include/soprano/soprano.h
include/soprano/soprano_export.h
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
include/soprano/sopranomacros.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/sopranotypes.h
Update to soprano 2.1.64 First beta of soprano 2.2. Required for KDE 4.2
2009-01-11 00:45:54 +01:00
include/soprano/sparqlmodel.h
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
include/soprano/statement.h
include/soprano/statementiterator.h
include/soprano/statementpattern.h
include/soprano/storagemodel.h
include/soprano/tcpclient.h
include/soprano/version.h
include/soprano/vocabulary.h
include/soprano/xesam.h
include/soprano/xsd.h
lib/libsoprano.so
lib/libsoprano.so.4
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
lib/libsoprano.so.4.3.0
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
lib/libsopranoclient.so
lib/libsopranoclient.so.1
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
lib/libsopranoclient.so.1.2.0
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
lib/libsopranoindex.so
lib/libsopranoindex.so.1
Update soprano to 2.3 * New class LanguageTag replacing the old simple string language handling with a sophisticated one implementing RFC 4647. At the same time Soprano now directly supports plain literals in addition to typed string literals (compare LiteralValue::createPlainLiteral). CAUTION: This patch changes behaviour: parsers and storage backends will now return plain literals instead of typed string literals! * New static methods Node::resourceToN3, Node::literalToN3, and Node::blankToN3 for easy N3 formatting without the creation of a Node instance. * Fixed both Node::matches and Statement::matches - now only the paramter is treated as a wildcard * sopranocmd: - new paramter --file which allows to execute commands on files directly without creating a database on disk. - standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added to sparql queries automatically if used. - construct and describe query results can now be serialized in all supported formats. - New parameter --index which allows to wrap an IndexFilterModel around the actual Model. - New command 'monitor' which allows to monitor a remote repository for statementAdded and statementRemoved signals. * New class Graph which is a simple QSet based container for statements as a quick replacement for Model in case one wants to handle a small number of statements without query support. * Fixed plugin loading on windows. * Fixed a deadlock in the IndexFilterModel in case a query could not be parsed. * Prevent Model::removeContext to remove empty contexts, i.e. the whole database. * Statement::operator<<(QTextStream) now uses a simpler format (only spaces between nodes and no brackets) * Updated Sesame2 to 2.2.4 * Added prefix handling to the Serializer API. For a future Soprano version the Serializer API has to be replaced with something more powerful. * Improved inference rule handling in the rule parser
2009-07-23 11:46:37 +02:00
lib/libsopranoindex.so.1.1.0
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
lib/libsopranoserver.so
lib/libsopranoserver.so.1
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
lib/libsopranoserver.so.1.2.0
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
lib/pkgconfig/soprano.pc
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
lib/pkgconfig/sopranoclient.pc
lib/pkgconfig/sopranoindex.pc
lib/pkgconfig/sopranoserver.pc
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
lib/soprano/libsoprano_nquadparser.so
lib/soprano/libsoprano_nquadserializer.so
lib/soprano/libsoprano_raptorparser.so
lib/soprano/libsoprano_raptorserializer.so
lib/soprano/libsoprano_redlandbackend.so
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
lib/soprano/libsoprano_virtuosobackend.so
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
share/dbus-1/interfaces/org.soprano.Model.xml
share/dbus-1/interfaces/org.soprano.NodeIterator.xml
share/dbus-1/interfaces/org.soprano.QueryResultIterator.xml
share/dbus-1/interfaces/org.soprano.Server.xml
share/dbus-1/interfaces/org.soprano.StatementIterator.xml
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
share/soprano/cmake/SopranoAddOntology.cmake
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
share/soprano/plugins/nquadparser.desktop
share/soprano/plugins/nquadserializer.desktop
share/soprano/plugins/raptorparser.desktop
share/soprano/plugins/raptorserializer.desktop
share/soprano/plugins/redlandbackend.desktop
Update to soprano 2.4.1 2.4.0 * New methods Client::SparqlModel::listStatementsAsync and Client::SparqlModel::listContextsAsync * Automatic query prefix expansion in NRLModel * Automatic NRL metadata graph removal in NRLModel * sopranocmd: - New paramter --nrl for sopranocmd which will trigger automatic query prefix expansion based on prefixes stored in the underlying model, automatic context creation for imported statements that do not have one set, and automatic metad ata graph removal on removeContext calls. - New parameter --graphselect which allows to convert SPARQL select query results into a graph result. This is very usable since SPARQL construct queries do not support contexts/named graphs. - New command 'rmgraph' which allows to delete a list of graphs/contexts. - New parameter --foo which enables scriptable binding results without variable names. * ServerCore is now fully multithreaded allowing two clients perform read-only commands simultaneously. * New Virtuoso storage backend which can either connect to a running Virtuoso instance or spawn one locally. * New convenience methods to handle BackendSettings. * New class AsyncQuery which will spawn a new thread for real asnycroneous query execution (in contrast to AsyncModel which only performs the actual query call in another thread while the iteration is syncroneous.) * Removed redland/librdf dependancy from raptor parser. 2.3.2 * Do not fail when trying to index empty strings, but ignore them. * Fixed parsing of plain literals with language code in sopranocmd. * Make onto2vocabularyclass work with the redland backend (not using graph SPARQL queries anymore) 2.3.1 * Changed installation path of cmake modules (SopranoAppOntology.cmake) to <prefix/share/soprano/cmake * Prevent the redland backend to add one statement multiple times. * Properly handle class names containing a dash '-' in onto2vocabularyclass * sopranocmd: Fail if trying to export a non-graph query
2010-04-10 02:02:03 +02:00
share/soprano/plugins/virtuosobackend.desktop
Import soprano 2.1 Soprano (formerly known as QRDF) is a library which provides a highly usable object-oriented C++/Qt4 framework for RDF data. It uses different RDF storage solutions as backends through a simple plugin system. Soprano is targetted at desktop applications that need a RDF data storage solution. It has been optimized for easy usage and simplicity.
2008-11-04 12:01:41 +01:00
share/soprano/rules/nrl.rules
share/soprano/rules/rdfs.rules
Reference in a new issue Copy permalink