/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <string.h>

#include <map>

#include <memory>

#include <mutex>

#include <set>

#include <string_view>

#include <iterator>

#include <algorithm>

#include <atomic>

#include <optional>

#include <libxslt/security.h>

#include <redland.h>

#include <com/sun/star/container/ElementExistException.hpp>

#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/lang/XInitialization.hpp>

#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>

#include <com/sun/star/lang/IllegalArgumentException.hpp>

#include <com/sun/star/io/XSeekable.hpp>

#include <com/sun/star/text/XTextRange.hpp>

#include <com/sun/star/rdf/ParseException.hpp>

#include <com/sun/star/rdf/QueryException.hpp>

#include <com/sun/star/rdf/RepositoryException.hpp>

#include <com/sun/star/rdf/XDocumentRepository.hpp>

#include <com/sun/star/rdf/XLiteral.hpp>

#include <com/sun/star/rdf/FileFormat.hpp>

#include <com/sun/star/rdf/BlankNode.hpp>

#include <com/sun/star/rdf/URI.hpp>

#include <com/sun/star/rdf/Literal.hpp>

#include <rtl/ref.hxx>

#include <rtl/ustrbuf.hxx>

#include <rtl/ustring.hxx>

#include <osl/diagnose.h>

#include <cppuhelper/exc_hlp.hxx>

#include <cppuhelper/implbase.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <unotools/weakref.hxx>

#include <comphelper/sequence.hxx>

#include <comphelper/xmltools.hxx>

#include <com/sun/star/embed/XEncryptionProtectedSource2.hpp>

#include <utility>

/**

    Implementation of the service com.sun.star.rdf.Repository.

    This implementation uses the Redland RDF library (librdf).

    There are several classes involved:

    librdf_TypeConverter:   helper class to convert data types redland <-> uno

    librdf_Repository:      the main repository, does almost all the work

    librdf_NamedGraph:      the XNamedGraph, forwards everything to repository

    librdf_GraphResult:     an XEnumeration<Statement>

    librdf_QuerySelectResult:   an XEnumeration<sequence<XNode>>

 */

/// anonymous implementation namespace

namespace {

class librdf_NamedGraph;

class librdf_Repository;

using namespace ::com::sun::star;

typedef std::map< OUString, ::rtl::Reference<librdf_NamedGraph> >

    NamedGraphMap_t;

const char s_sparql [] = "sparql";

const char s_nsOOo  [] = "http://openoffice.org/2004/office/rdfa/";

//FIXME: this approach is not ideal. can we use blank nodes instead?

bool isInternalContext(librdf_node *i_pNode) noexcept

{

    OSL_ENSURE(i_pNode, "isInternalContext: context null");

    OSL_ENSURE(librdf_node_is_resource(i_pNode),

        "isInternalContext: context not resource");

    if (i_pNode) {

        librdf_uri *pURI(librdf_node_get_uri(i_pNode));

        OSL_ENSURE(pURI, "isInternalContext: URI null");

        if (pURI) {

            unsigned char *pContextURI(librdf_uri_as_string(pURI));

            assert(pContextURI && "isInternalContext: URI string null");

            // if prefix matches reserved uri, it is RDFa context

            if (!strncmp(reinterpret_cast<char *>(pContextURI),

                    s_nsOOo, sizeof(s_nsOOo)-1)) {

                return true;

            }

        }

        return false;

    }

    return true;

}

// n.b.: librdf destructor functions dereference null pointers!

//       so they need to be wrapped to be usable with std::shared_ptr.

void safe_librdf_free_world(librdf_world *const world)

{

    if (world) { librdf_free_world(world); }

}

void safe_librdf_free_model(librdf_model *const model)

{

    if (model) { librdf_free_model(model); }

}

void safe_librdf_free_node(librdf_node* node)

{

    if (node) { librdf_free_node(node); }

}

void safe_librdf_free_parser(librdf_parser *const parser)

{

    if (parser) { librdf_free_parser(parser); }

}

void safe_librdf_free_query(librdf_query *const query)

{

    if (query) { librdf_free_query(query); }

}

void

safe_librdf_free_query_results(librdf_query_results *const query_results)

{

    if (query_results) { librdf_free_query_results(query_results); }

}

void safe_librdf_free_serializer(librdf_serializer *const serializer)

{

    if (serializer) { librdf_free_serializer(serializer); }

}

void safe_librdf_free_statement(librdf_statement *const statement)

{

    if (statement) { librdf_free_statement(statement); }

}

void safe_librdf_free_storage(librdf_storage *const storage)

{

    if (storage) { librdf_free_storage(storage); }

}

void safe_librdf_free_stream(librdf_stream *const stream)

{

    if (stream) { librdf_free_stream(stream); }

}

void safe_librdf_free_uri(librdf_uri *const uri)

{

    if (uri) { librdf_free_uri(uri); }

}

/** converts between librdf types and UNO API types.

 */

class librdf_TypeConverter

{

public:

    // some wrapper classes to temporarily hold values of UNO XNodes

    struct Node

    {

        virtual ~Node() {}

    };

    struct Resource : public Node { };

    struct URI : public Resource

    {

        OString const value;

        explicit URI(OString i_Value)

            : value(std::move(i_Value))

        { }

    };

    struct BlankNode : public Resource

    {

        OString const value;

        explicit BlankNode(OString i_Value)

            : value(std::move(i_Value))

        { }

    };

    struct Literal : public Node

    {

        OString const value;

        OString const language;

        ::std::optional<OString> const type;

        Literal(OString  i_rValue, OString i_Language,

                ::std::optional<OString> i_Type)

            : value(std::move(i_rValue))

            , language(std::move(i_Language))

            , type(std::move(i_Type))

        { }

    };

    struct Statement

    {

        std::shared_ptr<Resource> const pSubject;

        std::shared_ptr<URI> const pPredicate;

        std::shared_ptr<Node> const pObject;

        Statement(std::shared_ptr<Resource> i_pSubject,

                  std::shared_ptr<URI> i_pPredicate,

                  std::shared_ptr<Node> i_pObject)

            : pSubject(std::move(i_pSubject))

            , pPredicate(std::move(i_pPredicate))

            , pObject(std::move(i_pObject))

        { }

    };

    librdf_TypeConverter(

            uno::Reference< uno::XComponentContext > i_xContext,

            librdf_Repository &i_rRep)

        : m_xContext(std::move(i_xContext))

        , m_rRep(i_rRep)

    { };

    librdf_world *createWorld_Lock() const;

    librdf_storage *createStorage_Lock(librdf_world *i_pWorld) const;

    librdf_model *createModel_Lock(librdf_world *i_pWorld,

        librdf_storage * i_pStorage) const;

    static librdf_uri* mkURI_Lock(librdf_world* i_pWorld,

        const OString & i_rURI);

    static librdf_node* mkResource_Lock(librdf_world* i_pWorld,

        const Resource * i_pResource);

    static librdf_node* mkNode_Lock(librdf_world* i_pWorld,

        const Node * i_pNode);

    static librdf_statement* mkStatement_Lock(librdf_world* i_pWorld,

        Statement const& i_rStatement);

    static std::shared_ptr<Resource> extractResource_NoLock(

        const uno::Reference< rdf::XResource > & i_xResource);

    static void extractResourceToCacheKey_NoLock(

        const uno::Reference< rdf::XResource > & i_xResource,

        OUStringBuffer& rBuf);

    static std::shared_ptr<Node> extractNode_NoLock(

        const uno::Reference< rdf::XNode > & i_xNode);

    static void extractNodeToCacheKey_NoLock(

        const uno::Reference< rdf::XNode > & i_xNode,

        OUStringBuffer& rBuffer);

    static Statement extractStatement_NoLock(

        const uno::Reference< rdf::XResource > & i_xSubject,

        const uno::Reference< rdf::XURI > & i_xPredicate,

        const uno::Reference< rdf::XNode > & i_xObject);

    uno::Reference<rdf::XURI> convertToXURI(librdf_uri* i_pURI) const;

    uno::Reference<rdf::XURI> convertToXURI(librdf_node* i_pURI) const;

    uno::Reference<rdf::XResource>

        convertToXResource(librdf_node* i_pNode) const;

    uno::Reference<rdf::XNode> convertToXNode(librdf_node* i_pNode) const;

    rdf::Statement

        convertToStatement(librdf_statement* i_pStmt, librdf_node* i_pContext)

        const;

private:

    uno::Reference< uno::XComponentContext > const m_xContext;

    librdf_Repository & m_rRep;

};

/** implements the repository service.

 */

class librdf_Repository:

//    private ::cppu::BaseMutex,

    public ::cppu::WeakImplHelper<

        lang::XServiceInfo,

        rdf::XDocumentRepository,

        lang::XInitialization>

{

public:

    explicit librdf_Repository(

        uno::Reference< uno::XComponentContext > const & i_xContext);

    virtual ~librdf_Repository() override;

    // css::lang::XServiceInfo:

    virtual OUString SAL_CALL getImplementationName() override;

    virtual sal_Bool SAL_CALL supportsService(

            const OUString & ServiceName) override;

    virtual uno::Sequence< OUString > SAL_CALL

        getSupportedServiceNames() override;

    // css::rdf::XRepository:

    virtual uno::Reference< rdf::XBlankNode > SAL_CALL createBlankNode() override;

    virtual uno::Reference<rdf::XNamedGraph> SAL_CALL importGraph(

            ::sal_Int16 i_Format,

            const uno::Reference< io::XInputStream > & i_xInStream,

            const uno::Reference< rdf::XURI > & i_xGraphName,

            const uno::Reference< rdf::XURI > & i_xBaseURI) override;

    virtual void SAL_CALL exportGraph(::sal_Int16 i_Format,

            const uno::Reference< io::XOutputStream > & i_xOutStream,

            const uno::Reference< rdf::XURI > & i_xGraphName,

            const uno::Reference< rdf::XURI > & i_xBaseURI) override;

    virtual uno::Sequence< uno::Reference< rdf::XURI > > SAL_CALL

        getGraphNames() override;

    virtual uno::Reference< rdf::XNamedGraph > SAL_CALL getGraph(

            const uno::Reference< rdf::XURI > & i_xGraphName) override;

    virtual uno::Reference< rdf::XNamedGraph > SAL_CALL createGraph(

            const uno::Reference< rdf::XURI > & i_xGraphName) override;

    virtual void SAL_CALL destroyGraph(

            const uno::Reference< rdf::XURI > & i_xGraphName) override;

    virtual uno::Reference< container::XEnumeration > SAL_CALL getStatements(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject) override;

    virtual uno::Reference< rdf::XQuerySelectResult > SAL_CALL

            querySelect(const OUString & i_rQuery) override;

    virtual uno::Reference< container::XEnumeration > SAL_CALL

        queryConstruct(const OUString & i_rQuery) override;

    virtual sal_Bool SAL_CALL queryAsk(const OUString & i_rQuery) override;

    // css::rdf::XDocumentRepository:

    virtual void SAL_CALL setStatementRDFa(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Sequence< uno::Reference< rdf::XURI > > & i_rPredicates,

            const uno::Reference< rdf::XMetadatable > & i_xObject,

            const OUString & i_rRDFaContent,

            const uno::Reference< rdf::XURI > & i_xRDFaDatatype) override;

    virtual void SAL_CALL removeStatementRDFa(

            const uno::Reference< rdf::XMetadatable > & i_xElement) override;

    virtual beans::Pair< uno::Sequence<rdf::Statement>, sal_Bool > SAL_CALL

        getStatementRDFa(uno::Reference< rdf::XMetadatable > const& i_xElement) override;

    virtual uno::Reference< container::XEnumeration > SAL_CALL

        getStatementsRDFa(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject) override;

    // css::lang::XInitialization:

    virtual void SAL_CALL initialize(

            const uno::Sequence< css::uno::Any > & i_rArguments) override;

    // XNamedGraph forwards ---------------------------------------------

    NamedGraphMap_t::iterator clearGraph_NoLock(

            const OUString & i_rGraphName,

            bool i_Internal = false );

    NamedGraphMap_t::iterator clearGraph_Lock(

            const OUString & i_rGraphName,

            bool i_Internal);

    void addStatementGraph_NoLock(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject,

            const uno::Reference< rdf::XURI > & i_xName );

//        throw (uno::RuntimeException, lang::IllegalArgumentException,

//            container::NoSuchElementException, rdf::RepositoryException);

    void addStatementGraph_Lock(

        librdf_TypeConverter::Statement const& i_rStatement,

        OUString const& i_rGraphName,

        bool i_Internal);

    void removeStatementsGraph_NoLock(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject,

            const uno::Reference< rdf::XURI > & i_xName );

//        throw (uno::RuntimeException, lang::IllegalArgumentException,

//            container::NoSuchElementException, rdf::RepositoryException);

    std::vector<rdf::Statement> getStatementsGraph_NoLock(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject,

            const uno::Reference< rdf::XURI > & i_xName,

            bool i_Internal = false );

//        throw (uno::RuntimeException, lang::IllegalArgumentException,

//            container::NoSuchElementException, rdf::RepositoryException);

    const librdf_TypeConverter& getTypeConverter() const { return m_TypeConverter; };

private:

    librdf_Repository(librdf_Repository const&) = delete;

    librdf_Repository& operator=(librdf_Repository const&) = delete;

    /// this is const, no need to lock m_aMutex to access it

    uno::Reference< uno::XComponentContext > const m_xContext;

    /// librdf global data

    /** N.B.: The redland documentation gives the impression that you can have

              as many librdf_worlds as you like. This is true in the same sense

              that you can physically be in as many places as you like.

              Well, you can, just not at the same time.

              The ugly truth is that destroying a librdf_world kills a bunch

              of static variables; other librdf_worlds become very unhappy

              when they access these.

              And of course this is not documented anywhere that I could find.

              So we allocate a single world, and refcount that.

     */

    static std::shared_ptr<librdf_world> m_pWorld;

    /// refcount

    static sal_uInt32 m_NumInstances;

    /// mutex for m_pWorld - redland is not as threadsafe as is often claimed

    static std::mutex m_aMutex;

    // NB: sequence of the shared pointers is important!

    /// librdf repository storage

    std::shared_ptr<librdf_storage> m_pStorage;

    /// librdf repository model

    std::shared_ptr<librdf_model> m_pModel;

    /// all named graphs

    NamedGraphMap_t m_NamedGraphs;

    /// type conversion helper - stateless

    librdf_TypeConverter m_TypeConverter;

    /// set of xml:ids of elements with xhtml:content

    ::std::set< OUString > m_RDFaXHTMLContentSet;

};

/** result of operations that return a graph, i.e.,

    an XEnumeration of statements.

 */

class librdf_GraphResult:

    public ::cppu::WeakImplHelper<

        container::XEnumeration>

{

public:

    librdf_GraphResult(librdf_Repository *i_pRepository,

            std::mutex & i_rMutex,

            std::shared_ptr<librdf_stream> i_pStream,

            std::shared_ptr<librdf_node> i_pContext,

            std::shared_ptr<librdf_query> i_pQuery =

                std::shared_ptr<librdf_query>() )

        : m_xRep(i_pRepository)

        , m_rMutex(i_rMutex)

        , m_pQuery(std::move(i_pQuery))

        , m_pContext(std::move(i_pContext))

        , m_pStream(std::move(i_pStream))

    { };

    virtual ~librdf_GraphResult() override

    {

        std::scoped_lock g(m_rMutex); // lock mutex when destroying members

        const_cast<std::shared_ptr<librdf_stream>& >(m_pStream).reset();

        const_cast<std::shared_ptr<librdf_node>& >(m_pContext).reset();

        const_cast<std::shared_ptr<librdf_query>& >(m_pQuery).reset();

    }

    // css::container::XEnumeration:

    virtual sal_Bool SAL_CALL hasMoreElements() override;

    virtual uno::Any SAL_CALL nextElement() override;

private:

    librdf_GraphResult(librdf_GraphResult const&) = delete;

    librdf_GraphResult& operator=(librdf_GraphResult const&) = delete;

    // NB: this is not a weak pointer: streams _must_ be deleted before the

    //     storage they point into, so we keep the repository alive here

    // also, sequence is important: the stream must be destroyed first.

    ::rtl::Reference< librdf_Repository > m_xRep;

    // needed for synchronizing access to librdf (it doesn't do win32 threading)

    std::mutex & m_rMutex;

    // the query (in case this is a result of a graph query)

    // not that the redland documentation spells this out explicitly, but

    // queries must be freed only after all the results are completely read

    std::shared_ptr<librdf_query>  const m_pQuery;

    std::shared_ptr<librdf_node>   const m_pContext;

    std::shared_ptr<librdf_stream> const m_pStream;

    librdf_node* getContext_Lock() const;

};

// css::container::XEnumeration:

sal_Bool SAL_CALL

librdf_GraphResult::hasMoreElements()

{

    std::scoped_lock g(m_rMutex);

    return m_pStream && !librdf_stream_end(m_pStream.get());

}

librdf_node* librdf_GraphResult::getContext_Lock() const

{

    if (!m_pStream || librdf_stream_end(m_pStream.get()))

        return nullptr;

    librdf_node *pCtxt(

#if LIBRDF_VERSION >= 10012

        librdf_stream_get_context2(m_pStream.get()) );

#else

        static_cast<librdf_node *>(librdf_stream_get_context(m_pStream.get())) );

#endif

    if (pCtxt)

        return pCtxt;

    return m_pContext.get();

}

css::uno::Any SAL_CALL

librdf_GraphResult::nextElement()

{

    std::scoped_lock g(m_rMutex);

    if (m_pStream && librdf_stream_end(m_pStream.get())) {

        throw container::NoSuchElementException();

    }

    librdf_node * pCtxt = getContext_Lock();

    librdf_statement *pStmt( librdf_stream_get_object(m_pStream.get()) );

    if (!pStmt) {

        rdf::QueryException e(

            u"librdf_GraphResult::nextElement: "

            "librdf_stream_get_object failed"_ustr, *this);

        throw lang::WrappedTargetException(

            u"librdf_GraphResult::nextElement: "

            "librdf_stream_get_object failed"_ustr, *this,

                uno::Any(e));

    }

    // NB: pCtxt may be null here if this is result of a graph query

    if (pCtxt && isInternalContext(pCtxt)) {

        pCtxt = nullptr; // XML ID context is implementation detail!

    }

    rdf::Statement Stmt(

        m_xRep->getTypeConverter().convertToStatement(pStmt, pCtxt) );

    // NB: this will invalidate current item.

    librdf_stream_next(m_pStream.get());

    return uno::Any(Stmt);

}

/** result of operations that return a graph, i.e.,

    an XEnumeration of statements.

 */

class librdf_GraphResult2:

    public ::cppu::WeakImplHelper<

        container::XEnumeration>

{

public:

    librdf_GraphResult2(std::vector<rdf::Statement> statements)

        : m_vStatements(std::move(statements))

    { };

    // css::container::XEnumeration:

    virtual sal_Bool SAL_CALL hasMoreElements() override;

    virtual uno::Any SAL_CALL nextElement() override;

private:

    std::vector<rdf::Statement> m_vStatements;

    std::atomic<std::size_t> m_nIndex = 0;

};

// css::container::XEnumeration:

sal_Bool SAL_CALL

librdf_GraphResult2::hasMoreElements()

{

    return m_nIndex < m_vStatements.size();

}

css::uno::Any SAL_CALL

librdf_GraphResult2::nextElement()

{

    std::size_t const n = m_nIndex++;

    if (m_vStatements.size() <= n)

    {

        m_nIndex = m_vStatements.size(); // avoid overflow

        throw container::NoSuchElementException();

    }

    return uno::Any(m_vStatements[n]);

}

/** result of tuple queries ("SELECT").

 */

class librdf_QuerySelectResult:

    public ::cppu::WeakImplHelper<

        rdf::XQuerySelectResult>

{

public:

    librdf_QuerySelectResult(librdf_Repository *i_pRepository,

            std::mutex & i_rMutex,

            std::shared_ptr<librdf_query> i_pQuery,

            std::shared_ptr<librdf_query_results> i_pQueryResult,

            uno::Sequence< OUString > const& i_rBindingNames )

        : m_xRep(i_pRepository)

        , m_rMutex(i_rMutex)

        , m_pQuery(std::move(i_pQuery))

        , m_pQueryResult(std::move(i_pQueryResult))

        , m_BindingNames(i_rBindingNames)

    { };

    virtual ~librdf_QuerySelectResult() override

    {

        std::scoped_lock g(m_rMutex); // lock mutex when destroying members

        const_cast<std::shared_ptr<librdf_query_results>& >(m_pQueryResult)

            .reset();

        const_cast<std::shared_ptr<librdf_query>& >(m_pQuery).reset();

    }

    // css::container::XEnumeration:

    virtual sal_Bool SAL_CALL hasMoreElements() override;

    virtual uno::Any SAL_CALL nextElement() override;

    // css::rdf::XQuerySelectResult:

    virtual uno::Sequence< OUString > SAL_CALL getBindingNames() override;

private:

    librdf_QuerySelectResult(librdf_QuerySelectResult const&) = delete;

    librdf_QuerySelectResult& operator=(librdf_QuerySelectResult const&) = delete;

    // NB: this is not a weak pointer: streams _must_ be deleted before the

    //     storage they point into, so we keep the repository alive here

    // also, sequence is important: the stream must be destroyed first.

    ::rtl::Reference< librdf_Repository > m_xRep;

    // needed for synchronizing access to librdf (it doesn't do win32 threading)

    std::mutex & m_rMutex;

    // not that the redland documentation spells this out explicitly, but

    // queries must be freed only after all the results are completely read

    std::shared_ptr<librdf_query> const m_pQuery;

    std::shared_ptr<librdf_query_results> const m_pQueryResult;

    uno::Sequence< OUString > const m_BindingNames;

};

// css::container::XEnumeration:

sal_Bool SAL_CALL

librdf_QuerySelectResult::hasMoreElements()

{

    std::scoped_lock g(m_rMutex);

    return !librdf_query_results_finished(m_pQueryResult.get());

}

class NodeArray : private std::vector<librdf_node*>

{

public:

    NodeArray(int cnt) : std::vector<librdf_node*>(cnt) {}

    ~NodeArray() noexcept

    {

        std::for_each(begin(), end(), safe_librdf_free_node);

    }

    using std::vector<librdf_node*>::data;

    using std::vector<librdf_node*>::operator[];

};

css::uno::Any SAL_CALL

librdf_QuerySelectResult::nextElement()

{

    std::scoped_lock g(m_rMutex);

    if (librdf_query_results_finished(m_pQueryResult.get())) {

        throw container::NoSuchElementException();

    }

    sal_Int32 count(m_BindingNames.getLength());

    OSL_ENSURE(count >= 0, "negative length?");

    NodeArray aNodes(count);

    if (librdf_query_results_get_bindings(m_pQueryResult.get(), nullptr,

                aNodes.data()))

    {

        rdf::QueryException e(

            u"librdf_QuerySelectResult::nextElement: "

            "librdf_query_results_get_bindings failed"_ustr, *this);

        throw lang::WrappedTargetException(

            u"librdf_QuerySelectResult::nextElement: "

            "librdf_query_results_get_bindings failed"_ustr, *this,

            uno::Any(e));

    }

    uno::Sequence< uno::Reference< rdf::XNode > > ret(count);

    auto retRange = asNonConstRange(ret);

    for (int i = 0; i < count; ++i) {

        retRange[i] = m_xRep->getTypeConverter().convertToXNode(aNodes[i]);

    }

    // NB: this will invalidate current item.

    librdf_query_results_next(m_pQueryResult.get());

    return uno::Any(ret);

}

// css::rdf::XQuerySelectResult:

uno::Sequence< OUString > SAL_CALL

librdf_QuerySelectResult::getBindingNames()

{

    // const - no lock needed

    return m_BindingNames;

}

/** represents a named graph, and forwards all the work to repository.

 */

class librdf_NamedGraph:

    public ::cppu::WeakImplHelper<

        rdf::XNamedGraph>

{

public:

    librdf_NamedGraph(librdf_Repository * i_pRep,

            uno::Reference<rdf::XURI> i_xName)

        : m_wRep(i_pRep)

        , m_xName(std::move(i_xName))

    { };

    // css::rdf::XNode:

    virtual OUString SAL_CALL getStringValue() override;

    // css::rdf::XURI:

    virtual OUString SAL_CALL getNamespace() override;

    virtual OUString SAL_CALL getLocalName() override;

    // css::rdf::XNamedGraph:

    virtual uno::Reference<rdf::XURI> SAL_CALL getName() override;

    virtual void SAL_CALL clear() override;

    virtual void SAL_CALL addStatement(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject) override;

    virtual void SAL_CALL removeStatements(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject) override;

    virtual uno::Reference< container::XEnumeration > SAL_CALL getStatements(

            const uno::Reference< rdf::XResource > & i_xSubject,

            const uno::Reference< rdf::XURI > & i_xPredicate,

            const uno::Reference< rdf::XNode > & i_xObject) override;

private:

    librdf_NamedGraph(librdf_NamedGraph const&) = delete;

    librdf_NamedGraph& operator=(librdf_NamedGraph const&) = delete;

    static OUString createCacheKey_NoLock(

        const uno::Reference< rdf::XResource > & i_xSubject,

        const uno::Reference< rdf::XURI > & i_xPredicate,

        const uno::Reference< rdf::XNode > & i_xObject);

    /// weak reference: this is needed to check if m_pRep is valid

    unotools::WeakReference< librdf_Repository > const m_wRep;

    uno::Reference< rdf::XURI > const m_xName;

    /// Querying is rather slow, so cache the results.

    std::map<OUString, std::vector<rdf::Statement>> m_aStatementsCache;

    std::mutex m_CacheMutex;

};

// css::rdf::XNode:

OUString SAL_CALL librdf_NamedGraph::getStringValue()

{

    return m_xName->getStringValue();

}

// css::rdf::XURI:

OUString SAL_CALL librdf_NamedGraph::getNamespace()

{

    return m_xName->getNamespace();

}

OUString SAL_CALL librdf_NamedGraph::getLocalName()

{

    return m_xName->getLocalName();

}

// css::rdf::XNamedGraph:

uno::Reference< rdf::XURI > SAL_CALL librdf_NamedGraph::getName()

{

    return m_xName;

}

void SAL_CALL librdf_NamedGraph::clear()

{

    rtl::Reference< librdf_Repository > xRep( m_wRep );

    if (!xRep.is()) {

        throw rdf::RepositoryException(

            u"librdf_NamedGraph::clear: repository is gone"_ustr, *this);

    }

    const OUString contextU( m_xName->getStringValue() );

    try {

        xRep->clearGraph_NoLock(contextU);

    } catch (lang::IllegalArgumentException & ex) {

        css::uno::Any anyEx = cppu::getCaughtException();

        throw lang::WrappedTargetRuntimeException( ex.Message,

                        *this, anyEx );

    }

    std::unique_lock g(m_CacheMutex);

    m_aStatementsCache.clear();

}

void SAL_CALL librdf_NamedGraph::addStatement(

    const uno::Reference< rdf::XResource > & i_xSubject,

    const uno::Reference< rdf::XURI > & i_xPredicate,

    const uno::Reference< rdf::XNode > & i_xObject)

{

    rtl::Reference< librdf_Repository > xRep( m_wRep );

    if (!xRep.is()) {

        throw rdf::RepositoryException(

            u"librdf_NamedGraph::addStatement: repository is gone"_ustr, *this);

    }

    {

        std::unique_lock g(m_CacheMutex);

        m_aStatementsCache.clear();

    }

    xRep->addStatementGraph_NoLock(

            i_xSubject, i_xPredicate, i_xObject, m_xName);

}

void SAL_CALL librdf_NamedGraph::removeStatements(

    const uno::Reference< rdf::XResource > & i_xSubject,

    const uno::Reference< rdf::XURI > & i_xPredicate,

    const uno::Reference< rdf::XNode > & i_xObject)

{

    rtl::Reference< librdf_Repository > xRep( m_wRep );

    if (!xRep.is()) {

        throw rdf::RepositoryException(

            u"librdf_NamedGraph::removeStatements: repository is gone"_ustr, *this);

    }

    {

        std::unique_lock g(m_CacheMutex);

        m_aStatementsCache.clear();

    }

    xRep->removeStatementsGraph_NoLock(

            i_xSubject, i_xPredicate, i_xObject, m_xName);

}

OUString librdf_NamedGraph::createCacheKey_NoLock(

    const uno::Reference< rdf::XResource > & i_xSubject,

    const uno::Reference< rdf::XURI > & i_xPredicate,

    const uno::Reference< rdf::XNode > & i_xObject)

{

    OUStringBuffer cacheKey(256);

    librdf_TypeConverter::extractResourceToCacheKey_NoLock(i_xSubject, cacheKey);

    cacheKey.append("\t");

    librdf_TypeConverter::extractResourceToCacheKey_NoLock(i_xPredicate, cacheKey);

    cacheKey.append("\t");

    librdf_TypeConverter::extractNodeToCacheKey_NoLock(i_xObject, cacheKey);

    return cacheKey.makeStringAndClear();

}

uno::Reference< container::XEnumeration > SAL_CALL

librdf_NamedGraph::getStatements(

    const uno::Reference< rdf::XResource > & i_xSubject,

    const uno::Reference< rdf::XURI > & i_xPredicate,

    const uno::Reference< rdf::XNode > & i_xObject)

{

    OUString cacheKey = createCacheKey_NoLock(i_xSubject, i_xPredicate, i_xObject);

    {

        std::unique_lock g(m_CacheMutex);

        auto it = m_aStatementsCache.find(cacheKey);

        if (it != m_aStatementsCache.end()) {

            return new librdf_GraphResult2(it->second);

        }

    }

    rtl::Reference< librdf_Repository > xRep( m_wRep );

    if (!xRep.is()) {

        throw rdf::RepositoryException(

            u"librdf_NamedGraph::getStatements: repository is gone"_ustr, *this);

    }

    std::vector<rdf::Statement> vStatements = xRep->getStatementsGraph_NoLock(

            i_xSubject, i_xPredicate, i_xObject, m_xName);

    {

        std::unique_lock g(m_CacheMutex);

        m_aStatementsCache.emplace(cacheKey, vStatements);

    }

    return new librdf_GraphResult2(std::move(vStatements));

}

std::shared_ptr<librdf_world> librdf_Repository::m_pWorld;

sal_uInt32 librdf_Repository::m_NumInstances = 0;

std::mutex librdf_Repository::m_aMutex;

librdf_Repository::librdf_Repository(

        uno::Reference< uno::XComponentContext > const & i_xContext)

    : /*BaseMutex(),*/ m_xContext(i_xContext)

//    m_pWorld  (static_cast<librdf_world  *>(0), safe_librdf_free_world  ),

    , m_pStorage(static_cast<librdf_storage*>(nullptr), safe_librdf_free_storage)

    , m_pModel  (static_cast<librdf_model  *>(nullptr), safe_librdf_free_model  )

    , m_TypeConverter(i_xContext, *this)

{

    OSL_ENSURE(i_xContext.is(), "librdf_Repository: null context");

    std::scoped_lock g(m_aMutex);

    if (!m_NumInstances++) {

        m_pWorld.reset(m_TypeConverter.createWorld_Lock(),

                safe_librdf_free_world);

    }

}

librdf_Repository::~librdf_Repository()

{

    std::scoped_lock g(m_aMutex);

    // must destroy these before world!

    m_pModel.reset();

    m_pStorage.reset();

    // FIXME: so it turns out that calling librdf_free_world will

    //   (via raptor_sax2_finish) call xmlCleanupParser, which will

    //   free libxml2's globals! ARRRGH!!! => never call librdf_free_world

#if 0

    if (!--m_NumInstances) {

        m_pWorld.reset();

    }

#endif

}

// com.sun.star.uno.XServiceInfo:

OUString SAL_CALL librdf_Repository::getImplementationName()

{

    return u"librdf_Repository"_ustr;

}

sal_Bool SAL_CALL librdf_Repository::supportsService(

    OUString const & serviceName)

{

    return cppu::supportsService(this, serviceName);

}

uno::Sequence< OUString > SAL_CALL

librdf_Repository::getSupportedServiceNames()

{

    return { u"com.sun.star.rdf.Repository"_ustr };

}

// css::rdf::XRepository:

uno::Reference< rdf::XBlankNode > SAL_CALL librdf_Repository::createBlankNode()

{

    std::scoped_lock g(m_aMutex);

    const std::shared_ptr<librdf_node> pNode(

        librdf_new_node_from_blank_identifier(m_pWorld.get(), nullptr),

        safe_librdf_free_node);

    if (!pNode) {

        throw uno::RuntimeException(

            u"librdf_Repository::createBlankNode: "

            "librdf_new_node_from_blank_identifier failed"_ustr, *this);

    }

    const unsigned char * id (librdf_node_get_blank_identifier(pNode.get()));

    if (!id) {

        throw uno::RuntimeException(

            u"librdf_Repository::createBlankNode: "

            "librdf_node_get_blank_identifier failed"_ustr, *this);

    }

    const OUString nodeID(OUString::createFromAscii(

        reinterpret_cast<const char *>(id)));

    try {

        return rdf::BlankNode::create(m_xContext, nodeID);

    } catch (const lang::IllegalArgumentException &) {

        css::uno::Any anyEx = cppu::getCaughtException();

        throw lang::WrappedTargetRuntimeException(

                u"librdf_Repository::createBlankNode: "

                "illegal blank node label"_ustr, *this, anyEx);

    }

}

//void SAL_CALL

uno::Reference<rdf::XNamedGraph> SAL_CALL

librdf_Repository::importGraph(::sal_Int16 i_Format,

    const uno::Reference< io::XInputStream > & i_xInStream,

    const uno::Reference< rdf::XURI > & i_xGraphName,

    const uno::Reference< rdf::XURI > & i_xBaseURI)

{

    if (!i_xInStream.is()) {

        throw lang::IllegalArgumentException(

            u"librdf_Repository::importGraph: stream is null"_ustr, *this, 1);

    }

    //FIXME: other formats

    if (i_Format != rdf::FileFormat::RDF_XML) {

        throw datatransfer::UnsupportedFlavorException(

                u"librdf_Repository::importGraph: file format not supported"_ustr, *this);

    }

    if (!i_xGraphName.is()) {

        throw lang::IllegalArgumentException(

                u"librdf_Repository::importGraph: graph name is null"_ustr, *this, 2);

    }

    if (i_xGraphName->getStringValue().startsWith(s_nsOOo))

    {

        throw lang::IllegalArgumentException(

                u"librdf_Repository::importGraph: URI is reserved"_ustr, *this, 0);

    }

    if (!i_xBaseURI.is()) { //FIXME: any i_Format that don't need a base URI?

        throw lang::IllegalArgumentException(

                u"librdf_Repository::importGraph: base URI is null"_ustr, *this, 3);

    }

    OSL_ENSURE(i_xBaseURI.is(), "no base uri");

    const OUString baseURIU( i_xBaseURI->getStringValue() );

    if (baseURIU.indexOf('#') >= 0) {

        throw lang::IllegalArgumentException(

                u"librdf_Repository::importGraph: base URI is not absolute"_ustr, *this, 3);

    }

    const OUString contextU( i_xGraphName->getStringValue() );

    uno::Sequence<sal_Int8> buf;

    uno::Reference<io::XSeekable> xSeekable(i_xInStream, uno::UNO_QUERY);

    // UGLY: if only redland could read streams...

    const sal_Int64 sz( xSeekable.is() ? xSeekable->getLength() : 1 << 20 );

    // exceptions are propagated

    i_xInStream->readBytes( buf, static_cast<sal_Int32>( sz ) );

    if (buf.getLength() == 0) {

        throw rdf::ParseException(

            u"librdf_Repository::importGraph: stream is empty"_ustr, *this);

    }

    std::scoped_lock g(m_aMutex); // don't call i_x* with mutex locked

    if (m_NamedGraphs.find(contextU) != m_NamedGraphs.end()) {

        throw container::ElementExistException(

                u"librdf_Repository::importGraph: graph with given URI exists"_ustr, *this);

    }

    const OString context(

        OUStringToOString(contextU, RTL_TEXTENCODING_UTF8) );

    const std::shared_ptr<librdf_node> pContext(

        librdf_new_node_from_uri_string(m_pWorld.get(),

            reinterpret_cast<const unsigned char*> (context.getStr())),

        safe_librdf_free_node);

    if (!pContext) {

        throw uno::RuntimeException(

            u"librdf_Repository::importGraph: librdf_new_node_from_uri_string failed"_ustr, *this);