xref: /aoo42x/main/sfx2/source/doc/DocumentMetadataAccess.cxx (revision 45ad4d42)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#include "precompiled_sfx2.hxx"

#include <sfx2/DocumentMetadataAccess.hxx>

#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/embed/XTransactedObject.hpp>
#include <com/sun/star/task/ErrorCodeIOException.hpp>
#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
#include <com/sun/star/rdf/FileFormat.hpp>
#include <com/sun/star/rdf/URIs.hpp>
#include <com/sun/star/rdf/Statement.hpp>
#include <com/sun/star/rdf/Literal.hpp>
#include <com/sun/star/rdf/URI.hpp>
#include <com/sun/star/rdf/Repository.hpp>

#include <rtl/uuid.h>
#include <rtl/ustrbuf.hxx>
#include <rtl/uri.hxx>
#include <rtl/bootstrap.hxx>

#include <comphelper/interaction.hxx>
#include <comphelper/makesequence.hxx>
#include <comphelper/mediadescriptor.hxx>
#include <comphelper/sequenceasvector.hxx>
#include <comphelper/storagehelper.hxx>

#include <sfx2/docfile.hxx>
#include <sfx2/XmlIdRegistry.hxx>

#include <libxml/tree.h> // for xmlValidateNCName

#include <boost/bind.hpp>
#include <boost/shared_array.hpp>
#include <boost/tuple/tuple.hpp>

#include <vector>
#include <set>
#include <map>
#include <functional>
#include <algorithm>

#include <unotools/ucbhelper.hxx>
#include <com/sun/star/uri/XUriReference.hpp>
#include <com/sun/star/uri/XUriReferenceFactory.hpp>
#include <com/sun/star/uri/XVndSunStarPkgUrlReferenceFactory.hpp>


/*
 Note: in the context of this implementation, all rdf.QueryExceptions and
 rdf.RepositoryExceptions are RuntimeExceptions, and will be reported as such.

 This implementation assumes that it is only used with ODF documents, not mere
 ODF packages. In other words, we enforce that metadata files must not be
 called reserved names.
 */

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

namespace sfx2 {


bool isValidNCName(::rtl::OUString const & i_rIdref)
{
    const ::rtl::OString id(
        ::rtl::OUStringToOString(i_rIdref, RTL_TEXTENCODING_UTF8) );
    return !(xmlValidateNCName(
        reinterpret_cast<const unsigned char*>(id.getStr()), 0));
}

////////////////////////////////////////////////////////////////////////////

static const char s_content [] = "content.xml";
static const char s_styles  [] = "styles.xml";
static const char s_meta    [] = "meta.xml";
static const char s_settings[] = "settings.xml";
static const char s_manifest[] = "manifest.rdf";
static const char s_rdfxml  [] = "application/rdf+xml";
static const char s_odfmime [] = "application/vnd.oasis.opendocument.";

////////////////////////////////////////////////////////////////////////////

static bool isContentFile(::rtl::OUString const & i_rPath)
{
    return i_rPath.equalsAscii(s_content);
}

static bool isStylesFile (::rtl::OUString const & i_rPath)
{
    return i_rPath.equalsAscii(s_styles);
}

static bool isReservedFile(::rtl::OUString const & i_rPath)
{
    return isContentFile(i_rPath)
        || isStylesFile(i_rPath)
        || i_rPath.equalsAscii(s_meta)
        || i_rPath.equalsAscii(s_settings);
}

////////////////////////////////////////////////////////////////////////////

uno::Reference<rdf::XURI> createBaseURI(
    uno::Reference<uno::XComponentContext> const & i_xContext,
    uno::Reference<embed::XStorage> const & i_xStorage,
    ::rtl::OUString const & i_rPkgURI, ::rtl::OUString const & i_rSubDocument)
{
    if (!i_xContext.is() || !i_xStorage.is() || !i_rPkgURI.getLength()) {
        throw uno::RuntimeException();
    }

    // #i108078# workaround non-hierarchical vnd.sun.star.expand URIs
    // this really should be done somewhere else, not here.
    ::rtl::OUString pkgURI(i_rPkgURI);
    if (pkgURI.matchIgnoreAsciiCaseAsciiL(
            RTL_CONSTASCII_STRINGPARAM("vnd.sun.star.expand:")))
    {
        // expand it here (makeAbsolute requires hierarchical URI)
        pkgURI = pkgURI.copy( RTL_CONSTASCII_LENGTH("vnd.sun.star.expand:") );
        if (pkgURI.getLength() != 0) {
            pkgURI = ::rtl::Uri::decode(
                    pkgURI, rtl_UriDecodeStrict, RTL_TEXTENCODING_UTF8);
            if (pkgURI.getLength() == 0) {
                throw uno::RuntimeException();
            }
            ::rtl::Bootstrap::expandMacros(pkgURI);
        }
    }

    const uno::Reference<lang::XMultiComponentFactory> xServiceFactory(
        i_xContext->getServiceManager(), uno::UNO_SET_THROW);
    const uno::Reference<uri::XUriReferenceFactory> xUriFactory(
        xServiceFactory->createInstanceWithContext(
            ::rtl::OUString::createFromAscii(
                "com.sun.star.uri.UriReferenceFactory"), i_xContext),
        uno::UNO_QUERY_THROW);
    uno::Reference< uri::XUriReference > xBaseURI;

    const uno::Reference< uri::XUriReference > xPkgURI(
        xUriFactory->parse(pkgURI), uno::UNO_SET_THROW );
    xPkgURI->clearFragment();

    // need to know whether the storage is a FileSystemStorage
    // XServiceInfo would be better, but it is not implemented
//    if ( pkgURI.getLength() && ::utl::UCBContentHelper::IsFolder(pkgURI) )
    if (true) {
        xBaseURI.set( xPkgURI, uno::UNO_SET_THROW );
#if 0
    } else {
        const uno::Reference<uri::XVndSunStarPkgUrlReferenceFactory>
            xPkgUriFactory( xServiceFactory->createInstanceWithContext(
                ::rtl::OUString::createFromAscii(
                    "com.sun.star.uri.VndSunStarPkgUrlReferenceFactory"),
                i_xContext),
            uno::UNO_QUERY_THROW);
        xBaseURI.set( xPkgUriFactory->createVndSunStarPkgUrlReference(xPkgURI),
            uno::UNO_SET_THROW );
#endif
    }
    ::rtl::OUStringBuffer buf;
    if (!xBaseURI->getUriReference().endsWithAsciiL("/", 1))
    {
        const sal_Int32 count( xBaseURI->getPathSegmentCount() );
        if (count > 0)
        {
            const ::rtl::OUString last( xBaseURI->getPathSegment(count - 1) );
            buf.append(last);
        }
        buf.append(static_cast<sal_Unicode>('/'));
    }
    if (i_rSubDocument.getLength())
    {
        buf.append(i_rSubDocument);
        buf.append(static_cast<sal_Unicode>('/'));
    }
    const ::rtl::OUString Path(buf.makeStringAndClear());
    if (Path.getLength())
    {
        const uno::Reference< uri::XUriReference > xPathURI(
            xUriFactory->parse(Path), uno::UNO_SET_THROW );
        xBaseURI.set(
            xUriFactory->makeAbsolute(xBaseURI, xPathURI,
                true, uri::RelativeUriExcessParentSegments_ERROR),
            uno::UNO_SET_THROW);
    }

    return rdf::URI::create(i_xContext, xBaseURI->getUriReference());
}

////////////////////////////////////////////////////////////////////////////

struct DocumentMetadataAccess_Impl
{
    // note: these are all initialized in constructor, and loadFromStorage
    const uno::Reference<uno::XComponentContext> m_xContext;
    const IXmlIdRegistrySupplier & m_rXmlIdRegistrySupplier;
    uno::Reference<rdf::XURI> m_xBaseURI;
    uno::Reference<rdf::XRepository> m_xRepository;
    uno::Reference<rdf::XNamedGraph> m_xManifest;
    DocumentMetadataAccess_Impl(
            uno::Reference<uno::XComponentContext> const& i_xContext,
            IXmlIdRegistrySupplier const & i_rRegistrySupplier)
      : m_xContext(i_xContext)
      , m_rXmlIdRegistrySupplier(i_rRegistrySupplier)
      , m_xBaseURI()
      , m_xRepository()
      , m_xManifest()
    {
        OSL_ENSURE(m_xContext.is(), "context null");
    }
};

// this is... a hack.
template<sal_Int16 Constant>
/*static*/ uno::Reference<rdf::XURI>
getURI(uno::Reference< uno::XComponentContext > const & i_xContext)
{
    static uno::Reference< rdf::XURI > xURI(
        rdf::URI::createKnown(i_xContext, Constant), uno::UNO_QUERY_THROW);
    return xURI;
}


/** would storing the file to a XStorage succeed? */
static bool isFileNameValid(const ::rtl::OUString & i_rFileName)
{
    if (i_rFileName.getLength() <= 0) return false;
    if (i_rFileName[0] == '/')        return false; // no absolute paths!
    sal_Int32 idx(0);
    do {
      const ::rtl::OUString segment(
        i_rFileName.getToken(0, static_cast<sal_Unicode> ('/'), idx) );
      if (!segment.getLength()      ||  // no empty segments
          segment.equalsAscii(".")  ||  // no . segments
          segment.equalsAscii("..") ||  // no .. segments
          !::comphelper::OStorageHelper::IsValidZipEntryFileName(
              segment, sal_False))      // no invalid characters
                                      return false;
    } while (idx >= 0);
    return true;
}

/** split a uri hierarchy into first segment and rest */
static bool
splitPath(::rtl::OUString const & i_rPath,
    ::rtl::OUString & o_rDir, ::rtl::OUString& o_rRest)
{
    const sal_Int32 idx(i_rPath.indexOf(static_cast<sal_Unicode>('/')));
    if (idx < 0 || idx >= i_rPath.getLength()) {
        o_rDir = ::rtl::OUString();
        o_rRest = i_rPath;
        return true;
    } else if (idx == 0 || idx == i_rPath.getLength() - 1) {
        // input must not start or end with '/'
        return false;
    } else {
        o_rDir  = (i_rPath.copy(0, idx));
        o_rRest = (i_rPath.copy(idx+1));
        return true;
    }
}

static bool
splitXmlId(::rtl::OUString const & i_XmlId,
    ::rtl::OUString & o_StreamName, ::rtl::OUString& o_Idref )
{
    const sal_Int32 idx(i_XmlId.indexOf(static_cast<sal_Unicode>('#')));
    if ((idx <= 0) || (idx >= i_XmlId.getLength() - 1)) {
        return false;
    } else {
        o_StreamName = (i_XmlId.copy(0, idx));
        o_Idref      = (i_XmlId.copy(idx+1));
        return isValidXmlId(o_StreamName, o_Idref);
    }
}

////////////////////////////////////////////////////////////////////////////

static uno::Reference<rdf::XURI>
getURIForStream(struct DocumentMetadataAccess_Impl& i_rImpl,
    ::rtl::OUString const& i_rPath)
{
    const uno::Reference<rdf::XURI> xURI(
        rdf::URI::createNS( i_rImpl.m_xContext,
            i_rImpl.m_xBaseURI->getStringValue(), i_rPath),
        uno::UNO_SET_THROW);
    return xURI;
}

/** add statements declaring i_xResource to be a file of type i_xType with
    path i_rPath to manifest, with optional additional types i_pTypes */
static void
addFile(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference<rdf::XURI> const& i_xType,
    ::rtl::OUString const & i_rPath,
    const uno::Sequence < uno::Reference< rdf::XURI > > * i_pTypes = 0)
{
    try {
        const uno::Reference<rdf::XURI> xURI( getURIForStream(
            i_rImpl, i_rPath) );

        i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
            getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext),
            xURI.get());
        i_rImpl.m_xManifest->addStatement(xURI.get(),
            getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
            i_xType.get());
        if (i_pTypes) {
            for (sal_Int32 i = 0; i < i_pTypes->getLength(); ++i) {
                i_rImpl.m_xManifest->addStatement(xURI.get(),
                    getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
                    (*i_pTypes)[i].get());
            }
        }
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "addFile: exception"), /*this*/0, uno::makeAny(e));
    }
}

/** add content.xml or styles.xml to manifest */
static bool
addContentOrStylesFileImpl(struct DocumentMetadataAccess_Impl & i_rImpl,
    const ::rtl::OUString & i_rPath)
{
    uno::Reference<rdf::XURI> xType;
    if (isContentFile(i_rPath)) {
        xType.set(getURI<rdf::URIs::ODF_CONTENTFILE>(i_rImpl.m_xContext));
    } else if (isStylesFile(i_rPath)) {
        xType.set(getURI<rdf::URIs::ODF_STYLESFILE>(i_rImpl.m_xContext));
    } else {
        return false;
    }
    addFile(i_rImpl, xType.get(), i_rPath);
    return true;
}

/** add metadata file to manifest */
static void
addMetadataFileImpl(struct DocumentMetadataAccess_Impl & i_rImpl,
    const ::rtl::OUString & i_rPath,
    const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
{
    addFile(i_rImpl,
            getURI<rdf::URIs::PKG_METADATAFILE>(i_rImpl.m_xContext),
            i_rPath, &i_rTypes);
}

/** remove a file from the manifest */
static void
removeFile(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference<rdf::XURI> const& i_xPart)
{
    if (!i_xPart.is()) throw uno::RuntimeException();
    try {
        i_rImpl.m_xManifest->removeStatements(i_rImpl.m_xBaseURI.get(),
            getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext),
            i_xPart.get());
        i_rImpl.m_xManifest->removeStatements(i_xPart.get(),
            getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), 0);
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii("removeFile: exception"),
            0, uno::makeAny(e));
    }
}

static ::std::vector< uno::Reference< rdf::XURI > >
getAllParts(struct DocumentMetadataAccess_Impl & i_rImpl)
{
    ::std::vector< uno::Reference< rdf::XURI > > ret;
    try {
        const uno::Reference<container::XEnumeration> xEnum(
            i_rImpl.m_xManifest->getStatements( i_rImpl.m_xBaseURI.get(),
                getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), 0),
            uno::UNO_SET_THROW);
        while (xEnum->hasMoreElements()) {
            rdf::Statement stmt;
            if (!(xEnum->nextElement() >>= stmt)) {
                throw uno::RuntimeException();
            }
            const uno::Reference<rdf::XURI> xPart(stmt.Object,
                uno::UNO_QUERY);
            if (!xPart.is()) continue;
            ret.push_back(xPart);
        }
        return ret;
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii("getAllParts: exception"),
            0, uno::makeAny(e));
    }
}

static bool
isPartOfType(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference<rdf::XURI> const & i_xPart,
    uno::Reference<rdf::XURI> const & i_xType)
{
    if (!i_xPart.is() || !i_xType.is()) throw uno::RuntimeException();
    try {
        const uno::Reference<container::XEnumeration> xEnum(
            i_rImpl.m_xManifest->getStatements(i_xPart.get(),
                getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
                i_xType.get()),
            uno::UNO_SET_THROW);
        return (xEnum->hasMoreElements());
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii("isPartOfType: exception"),
            0, uno::makeAny(e));
    }
}

////////////////////////////////////////////////////////////////////////////

static ucb::InteractiveAugmentedIOException
mkException( ::rtl::OUString const & i_rMessage,
    ucb::IOErrorCode const i_ErrorCode,
    ::rtl::OUString const & i_rUri, ::rtl::OUString const & i_rResource)
{
    ucb::InteractiveAugmentedIOException iaioe;
    iaioe.Message = i_rMessage;
    iaioe.Classification = task::InteractionClassification_ERROR;
    iaioe.Code = i_ErrorCode;

    const beans::PropertyValue uriProp(::rtl::OUString::createFromAscii("Uri"),
        -1, uno::makeAny(i_rUri), static_cast<beans::PropertyState>(0));
    const beans::PropertyValue rnProp(
        ::rtl::OUString::createFromAscii("ResourceName"),
        -1, uno::makeAny(i_rResource), static_cast<beans::PropertyState>(0));
    iaioe.Arguments = ::comphelper::makeSequence(
        uno::makeAny(uriProp), uno::makeAny(rnProp));
    return iaioe;
}

/** error handling policy.
    <p>If a handler is given, ask it how to proceed:
    <ul><li>(default:) cancel import, raise exception</li>
        <li>ignore the error and continue</li>
        <li>retry the action that led to the error</li></ul></p>
    N.B.: must not be called before DMA is fully initialized!
    @returns true if caller should retry
 */
static bool
handleError( ucb::InteractiveAugmentedIOException const & i_rException,
    const uno::Reference<task::XInteractionHandler> & i_xHandler)
{
    if (!i_xHandler.is()) {
        throw lang::WrappedTargetException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: exception"),
            /* *this*/ 0, uno::makeAny(i_rException));
    }

    ::rtl::Reference< ::comphelper::OInteractionRequest > pRequest(
        new ::comphelper::OInteractionRequest(uno::makeAny(i_rException)) );
    ::rtl::Reference< ::comphelper::OInteractionRetry > pRetry(
        new ::comphelper::OInteractionRetry );
    ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove(
        new ::comphelper::OInteractionApprove );
    ::rtl::Reference< ::comphelper::OInteractionAbort > pAbort(
        new ::comphelper::OInteractionAbort );
    /* this does not seem to work
    if (i_rException.Code != ucb::IOErrorCode_WRONG_FORMAT) {
        pRequest->addContinuation( pRetry.get() );
    }
    */
    pRequest->addContinuation( pApprove.get() );
    pRequest->addContinuation( pAbort.get() );
    // actually call the handler
    i_xHandler->handle( pRequest.get() );
    if (pRetry->wasSelected()) {
        return true;
    } else if (pApprove->wasSelected()) {
        return false;
    } else {
        OSL_ENSURE(pAbort->wasSelected(), "no continuation selected?");
        throw lang::WrappedTargetException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: exception"),
            /* *this*/ 0, uno::makeAny(i_rException));
    }
}

/** check if storage has content.xml/styles.xml;
    e.g. ODB files seem to only have content.xml */
static void
collectFilesFromStorage(uno::Reference<embed::XStorage> const& i_xStorage,
    ::rtl::OUString i_Path,
    std::set< ::rtl::OUString > & o_rFiles)
{
    static ::rtl::OUString content(::rtl::OUString::createFromAscii(s_content));
    static ::rtl::OUString styles (::rtl::OUString::createFromAscii(s_styles ));
    try {
        if (i_xStorage->hasByName(content) &&
            i_xStorage->isStreamElement(content))
        {
            o_rFiles.insert(i_Path + content);
        }
        if (i_xStorage->hasByName(styles) &&
            i_xStorage->isStreamElement(styles))
        {
            o_rFiles.insert(i_Path + styles);
        }
    } catch (uno::Exception &) {
        OSL_TRACE("collectFilesFromStorage: exception?");
    }
}

/** import a metadata file into repository */
static void
readStream(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference< embed::XStorage > const & i_xStorage,
    ::rtl::OUString const & i_rPath,
    ::rtl::OUString const & i_rBaseURI)
{
    ::rtl::OUString dir;
    ::rtl::OUString rest;
    try {
        if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException();
        if (dir.equalsAscii("")) {
            if (i_xStorage->isStreamElement(i_rPath)) {
                const uno::Reference<io::XStream> xStream(
                    i_xStorage->openStreamElement(i_rPath,
                        embed::ElementModes::READ), uno::UNO_SET_THROW);
                const uno::Reference<io::XInputStream> xInStream(
                    xStream->getInputStream(), uno::UNO_SET_THROW );
                const uno::Reference<rdf::XURI> xBaseURI(
                    rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI));
                const uno::Reference<rdf::XURI> xURI(
                    rdf::URI::createNS(i_rImpl.m_xContext,
                        i_rBaseURI, i_rPath));
                i_rImpl.m_xRepository->importGraph(rdf::FileFormat::RDF_XML,
                    xInStream, xURI, xBaseURI);
            } else {
                throw mkException(::rtl::OUString::createFromAscii(
                    "readStream: is not a stream"),
                    ucb::IOErrorCode_NO_FILE, i_rBaseURI + i_rPath, i_rPath);
            }
        } else {
            if (i_xStorage->isStorageElement(dir)) {
                const uno::Reference<embed::XStorage> xDir(
                    i_xStorage->openStorageElement(dir,
                        embed::ElementModes::READ));
                const uno::Reference< beans::XPropertySet > xDirProps(xDir,
                    uno::UNO_QUERY_THROW);
                try {
                    ::rtl::OUString mimeType;
                    xDirProps->getPropertyValue(
                            ::comphelper::MediaDescriptor::PROP_MEDIATYPE() )
                        >>= mimeType;
                    if (mimeType.matchAsciiL(s_odfmime, sizeof(s_odfmime) - 1))
                    {
                        OSL_TRACE("readStream: "
                            "refusing to recurse into embedded document");
                        return;
                    }
                } catch (uno::Exception &) { }
                ::rtl::OUStringBuffer buf(i_rBaseURI);
                buf.append(dir).append(static_cast<sal_Unicode>('/'));
                readStream(i_rImpl, xDir, rest, buf.makeStringAndClear() );
            } else {
                throw mkException(::rtl::OUString::createFromAscii(
                    "readStream: is not a directory"),
                    ucb::IOErrorCode_NO_DIRECTORY, i_rBaseURI + dir, dir);
            }
        }
    } catch (container::NoSuchElementException & e) {
        throw mkException(e.Message, ucb::IOErrorCode_NOT_EXISTING_PATH,
            i_rBaseURI + i_rPath, i_rPath);
    } catch (io::IOException & e) {
        throw mkException(e.Message, ucb::IOErrorCode_CANT_READ,
            i_rBaseURI + i_rPath, i_rPath);
    } catch (rdf::ParseException & e) {
        throw mkException(e.Message, ucb::IOErrorCode_WRONG_FORMAT,
            i_rBaseURI + i_rPath, i_rPath);
    }
}

/** import a metadata file into repository */
static void
importFile(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference<embed::XStorage> const & i_xStorage,
    ::rtl::OUString const & i_rBaseURI,
    uno::Reference<task::XInteractionHandler> const & i_xHandler,
    ::rtl::OUString i_rPath)
{
retry:
    try {
        readStream(i_rImpl, i_xStorage, i_rPath, i_rBaseURI);
    } catch (ucb::InteractiveAugmentedIOException & e) {
        if (handleError(e, i_xHandler)) goto retry;
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii("importFile: exception"),
            0, uno::makeAny(e));
    }
}

/** actually write a metadata file to the storage */
static void
exportStream(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference< embed::XStorage > const & i_xStorage,
    uno::Reference<rdf::XURI> const & i_xGraphName,
    ::rtl::OUString const & i_rFileName,
    ::rtl::OUString const & i_rBaseURI)
{
    const uno::Reference<io::XStream> xStream(
        i_xStorage->openStreamElement(i_rFileName,
            embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE),
        uno::UNO_SET_THROW);
    const uno::Reference< beans::XPropertySet > xStreamProps(xStream,
        uno::UNO_QUERY);
    if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage
        xStreamProps->setPropertyValue(
            ::rtl::OUString::createFromAscii("MediaType"),
            uno::makeAny(::rtl::OUString::createFromAscii(s_rdfxml)));
    }
    const uno::Reference<io::XOutputStream> xOutStream(
        xStream->getOutputStream(), uno::UNO_SET_THROW );
    const uno::Reference<rdf::XURI> xBaseURI(
        rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI));
    i_rImpl.m_xRepository->exportGraph(rdf::FileFormat::RDF_XML,
        xOutStream, i_xGraphName, xBaseURI);
}

/** write a metadata file to the storage */
static void
writeStream(struct DocumentMetadataAccess_Impl & i_rImpl,
    uno::Reference< embed::XStorage > const & i_xStorage,
    uno::Reference<rdf::XURI> const & i_xGraphName,
    ::rtl::OUString const & i_rPath,
    ::rtl::OUString const & i_rBaseURI)
{
    ::rtl::OUString dir;
    ::rtl::OUString rest;
    if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException();
    try {
        if (dir.equalsAscii("")) {
            exportStream(i_rImpl, i_xStorage, i_xGraphName, i_rPath,
                i_rBaseURI);
        } else {
            const uno::Reference<embed::XStorage> xDir(
                i_xStorage->openStorageElement(dir,
                    embed::ElementModes::WRITE));
            const uno::Reference< beans::XPropertySet > xDirProps(xDir,
                uno::UNO_QUERY_THROW);
            try {
                ::rtl::OUString mimeType;
                xDirProps->getPropertyValue(
                        ::comphelper::MediaDescriptor::PROP_MEDIATYPE() )
                    >>= mimeType;
                if (mimeType.matchAsciiL(s_odfmime, sizeof(s_odfmime) - 1)) {
                    OSL_TRACE("writeStream: "
                        "refusing to recurse into embedded document");
                    return;
                }
            } catch (uno::Exception &) { }
            ::rtl::OUStringBuffer buf(i_rBaseURI);
            buf.append(dir).append(static_cast<sal_Unicode>('/'));
            writeStream(i_rImpl, xDir, i_xGraphName, rest,
                buf.makeStringAndClear());
            uno::Reference<embed::XTransactedObject> const xTransaction(
                xDir, uno::UNO_QUERY);
            if (xTransaction.is()) {
                xTransaction->commit();
            }
        }
    } catch (uno::RuntimeException &) {
        throw;
    } catch (io::IOException &) {
        throw;
    }
}

static void
initLoading(struct DocumentMetadataAccess_Impl & i_rImpl,
    const uno::Reference< embed::XStorage > & i_xStorage,
    const uno::Reference<rdf::XURI> & i_xBaseURI,
    const uno::Reference<task::XInteractionHandler> & i_xHandler)
{
retry:
    // clear old data
    i_rImpl.m_xManifest.clear();
    // init BaseURI
    i_rImpl.m_xBaseURI = i_xBaseURI;

    // create repository
    i_rImpl.m_xRepository.clear();
    i_rImpl.m_xRepository.set(rdf::Repository::create(i_rImpl.m_xContext),
            uno::UNO_SET_THROW);

    const ::rtl::OUString manifest (
            ::rtl::OUString::createFromAscii(s_manifest));
    const ::rtl::OUString baseURI( i_xBaseURI->getStringValue() );
    // try to delay raising errors until after initialization is done
    uno::Any rterr;
    ucb::InteractiveAugmentedIOException iaioe;
    bool err(false);

    const uno::Reference <rdf::XURI> xManifest(
        getURIForStream(i_rImpl, manifest));
    try {
        readStream(i_rImpl, i_xStorage, manifest, baseURI);
    } catch (ucb::InteractiveAugmentedIOException & e) {
        // no manifest.rdf: this is not an error in ODF < 1.2
        if (!(ucb::IOErrorCode_NOT_EXISTING_PATH == e.Code)) {
            iaioe = e;
            err = true;
        }
    } catch (uno::Exception & e) {
        rterr <<= e;
    }

    // init manifest graph
    const uno::Reference<rdf::XNamedGraph> xManifestGraph(
        i_rImpl.m_xRepository->getGraph(xManifest));
    i_rImpl.m_xManifest.set(xManifestGraph.is() ? xManifestGraph :
        i_rImpl.m_xRepository->createGraph(xManifest), uno::UNO_SET_THROW);
    const uno::Reference<container::XEnumeration> xEnum(
        i_rImpl.m_xManifest->getStatements(0,
            getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
            getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get()));

    // document statement
    i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
        getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
        getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get());

    OSL_ENSURE(i_rImpl.m_xBaseURI.is(), "base URI is null");
    OSL_ENSURE(i_rImpl.m_xRepository.is(), "repository is null");
    OSL_ENSURE(i_rImpl.m_xManifest.is(), "manifest is null");

    if (rterr.hasValue()) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::loadMetadataFromStorage: "
                "exception"), 0, rterr);
    }

    if (err) {
        if (handleError(iaioe, i_xHandler)) goto retry;
    }
}

/** init Impl struct */
static void init(struct DocumentMetadataAccess_Impl & i_rImpl)
{
    try {

        i_rImpl.m_xManifest.set(i_rImpl.m_xRepository->createGraph(
            getURIForStream(i_rImpl,
                ::rtl::OUString::createFromAscii(s_manifest))),
            uno::UNO_SET_THROW);

        // insert the document statement
        i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI.get(),
            getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext),
            getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext).get());
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii("init: unexpected exception"), 0,
            uno::makeAny(e));
    }

    // add top-level content files
    if (!addContentOrStylesFileImpl(i_rImpl,
            ::rtl::OUString::createFromAscii(s_content))) {
        throw uno::RuntimeException();
    }
    if (!addContentOrStylesFileImpl(i_rImpl,
            ::rtl::OUString::createFromAscii(s_styles))) {
        throw uno::RuntimeException();
    }
}


////////////////////////////////////////////////////////////////////////////

DocumentMetadataAccess::DocumentMetadataAccess(
        uno::Reference< uno::XComponentContext > const & i_xContext,
        const IXmlIdRegistrySupplier & i_rRegistrySupplier)
    : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier))
{
    // no initialization: must call loadFrom...
}

DocumentMetadataAccess::DocumentMetadataAccess(
        uno::Reference< uno::XComponentContext > const & i_xContext,
        const IXmlIdRegistrySupplier & i_rRegistrySupplier,
        ::rtl::OUString const & i_rURI)
    : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier))
{
    OSL_ENSURE(i_rURI.getLength(), "DMA::DMA: no URI given!");
    OSL_ENSURE(i_rURI.endsWithAsciiL("/", 1), "DMA::DMA: URI without / given!");
    if (!i_rURI.endsWithAsciiL("/", 1)) throw uno::RuntimeException();
    m_pImpl->m_xBaseURI.set(rdf::URI::create(m_pImpl->m_xContext, i_rURI));
    m_pImpl->m_xRepository.set(rdf::Repository::create(m_pImpl->m_xContext),
            uno::UNO_SET_THROW);

    // init repository
    init(*m_pImpl);

    OSL_ENSURE(m_pImpl->m_xBaseURI.is(), "base URI is null");
    OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository is null");
    OSL_ENSURE(m_pImpl->m_xManifest.is(), "manifest is null");
}

DocumentMetadataAccess::~DocumentMetadataAccess()
{
}


// ::com::sun::star::rdf::XRepositorySupplier:
uno::Reference< rdf::XRepository > SAL_CALL
DocumentMetadataAccess::getRDFRepository() throw (uno::RuntimeException)
{
    OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository not initialized");
    return m_pImpl->m_xRepository;
}

// ::com::sun::star::rdf::XNode:
::rtl::OUString SAL_CALL
DocumentMetadataAccess::getStringValue() throw (uno::RuntimeException)
{
    return m_pImpl->m_xBaseURI->getStringValue();
}

// ::com::sun::star::rdf::XURI:
::rtl::OUString SAL_CALL
DocumentMetadataAccess::getNamespace() throw (uno::RuntimeException)
{
    return m_pImpl->m_xBaseURI->getNamespace();
}

::rtl::OUString SAL_CALL
DocumentMetadataAccess::getLocalName() throw (uno::RuntimeException)
{
    return m_pImpl->m_xBaseURI->getLocalName();
}

// ::com::sun::star::rdf::XDocumentMetadataAccess:
uno::Reference< rdf::XMetadatable > SAL_CALL
DocumentMetadataAccess::getElementByMetadataReference(
    const ::com::sun::star::beans::StringPair & i_rReference)
throw (uno::RuntimeException)
{
    const IXmlIdRegistry * pReg(
        m_pImpl->m_rXmlIdRegistrySupplier.GetXmlIdRegistry() );
    if (!pReg) {
        throw uno::RuntimeException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::getElementByXmlId: no registry"), *this);
    }
    return pReg->GetElementByMetadataReference(i_rReference);
}

uno::Reference< rdf::XMetadatable > SAL_CALL
DocumentMetadataAccess::getElementByURI(
    const uno::Reference< rdf::XURI > & i_xURI )
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
    if (!i_xURI.is()) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::getElementByURI: URI is null"), *this, 0);
    }

    const ::rtl::OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() );
    const ::rtl::OUString name( i_xURI->getStringValue() );
    if (!name.match(baseURI)) {
        return 0;
    }
    const ::rtl::OUString relName( name.copy(baseURI.getLength()) );
    ::rtl::OUString path;
    ::rtl::OUString idref;
    if (!splitXmlId(relName, path, idref)) {
        return 0;
    }

    return getElementByMetadataReference( beans::StringPair(path, idref) );
}


uno::Sequence< uno::Reference< rdf::XURI > > SAL_CALL
DocumentMetadataAccess::getMetadataGraphsWithType(
    const uno::Reference<rdf::XURI> & i_xType)
throw (uno::RuntimeException, lang::IllegalArgumentException)
{
    if (!i_xType.is()) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::getMetadataGraphsWithType: "
            "type is null"), *this, 0);
    }

    ::comphelper::SequenceAsVector< uno::Reference< rdf::XURI > > ret;
    const ::std::vector< uno::Reference< rdf::XURI > > parts(
        getAllParts(*m_pImpl) );
    ::std::remove_copy_if(parts.begin(), parts.end(),
        ::std::back_inserter(ret),
        ::boost::bind(
            ::std::logical_not<bool>(),
            ::boost::bind(&isPartOfType, ::boost::ref(*m_pImpl), _1, i_xType) ));
    return ret.getAsConstList();
}

uno::Reference<rdf::XURI> SAL_CALL
DocumentMetadataAccess::addMetadataFile(const ::rtl::OUString & i_rFileName,
    const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    container::ElementExistException)
{
    if (!isFileNameValid(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::addMetadataFile: invalid FileName"),
            *this, 0);
    }
    if (isReservedFile(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::addMetadataFile:"
            "invalid FileName: reserved"), *this, 0);
    }
    for (sal_Int32 i = 0; i < i_rTypes.getLength(); ++i) {
        if (!i_rTypes[i].is()) {
            throw lang::IllegalArgumentException(
                ::rtl::OUString::createFromAscii(
                    "DocumentMetadataAccess::addMetadataFile: "
                    "null type"), *this, 2);
        }
    }

    const uno::Reference<rdf::XURI> xGraphName(
        getURIForStream(*m_pImpl, i_rFileName) );

    try {
        m_pImpl->m_xRepository->createGraph(xGraphName);
    } catch (rdf::RepositoryException & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::addMetadataFile: exception"),
            *this, uno::makeAny(e));
        // note: all other exceptions are propagated
    }

    addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes);
    return xGraphName;
}

uno::Reference<rdf::XURI> SAL_CALL
DocumentMetadataAccess::importMetadataFile(::sal_Int16 i_Format,
    const uno::Reference< io::XInputStream > & i_xInStream,
    const ::rtl::OUString & i_rFileName,
    const uno::Reference< rdf::XURI > & i_xBaseURI,
    const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    datatransfer::UnsupportedFlavorException,
    container::ElementExistException, rdf::ParseException, io::IOException)
{
    if (!isFileNameValid(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::importMetadataFile: invalid FileName"),
            *this, 0);
    }
    if (isReservedFile(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::importMetadataFile:"
            "invalid FileName: reserved"), *this, 0);
    }
    for (sal_Int32 i = 0; i < i_rTypes.getLength(); ++i) {
        if (!i_rTypes[i].is()) {
            throw lang::IllegalArgumentException(
                ::rtl::OUString::createFromAscii(
                    "DocumentMetadataAccess::importMetadataFile: null type"),
                *this, 5);
        }
    }

    const uno::Reference<rdf::XURI> xGraphName(
        getURIForStream(*m_pImpl, i_rFileName) );

    try {
        m_pImpl->m_xRepository->importGraph(
            i_Format, i_xInStream, xGraphName, i_xBaseURI);
    } catch (rdf::RepositoryException & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::importMetadataFile: "
                "RepositoryException"), *this, uno::makeAny(e));
        // note: all other exceptions are propagated
    }

    // add to manifest
    addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes);
    return xGraphName;
}

void SAL_CALL
DocumentMetadataAccess::removeMetadataFile(
    const uno::Reference< rdf::XURI > & i_xGraphName)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    container::NoSuchElementException)
{
    try {
        m_pImpl->m_xRepository->destroyGraph(i_xGraphName);
    } catch (rdf::RepositoryException & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::removeMetadataFile: "
                "RepositoryException"), *this, uno::makeAny(e));
        // note: all other exceptions are propagated
    }

    // remove file from manifest
    removeFile(*m_pImpl, i_xGraphName.get());
}

void SAL_CALL
DocumentMetadataAccess::addContentOrStylesFile(
    const ::rtl::OUString & i_rFileName)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    container::ElementExistException)
{
    if (!isFileNameValid(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::addContentOrStylesFile: "
            "invalid FileName"), *this, 0);
    }

    if (!addContentOrStylesFileImpl(*m_pImpl, i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::addContentOrStylesFile: "
            "invalid FileName: must end with content.xml or styles.xml"),
            *this, 0);
    }
}

void SAL_CALL
DocumentMetadataAccess::removeContentOrStylesFile(
    const ::rtl::OUString & i_rFileName)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    container::NoSuchElementException)
{
    if (!isFileNameValid(i_rFileName)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::removeContentOrStylesFile: "
            "invalid FileName"), *this, 0);
    }

    try {
        const uno::Reference<rdf::XURI> xPart(
            getURIForStream(*m_pImpl, i_rFileName) );
        const uno::Reference<container::XEnumeration> xEnum(
            m_pImpl->m_xManifest->getStatements( m_pImpl->m_xBaseURI.get(),
                getURI<rdf::URIs::PKG_HASPART>(m_pImpl->m_xContext),
                xPart.get()),
            uno::UNO_SET_THROW);
        if (!xEnum->hasMoreElements()) {
            throw container::NoSuchElementException(
                ::rtl::OUString::createFromAscii(
                    "DocumentMetadataAccess::removeContentOrStylesFile: "
                    "cannot find stream in manifest graph: ") + i_rFileName,
                *this);
        }

        // remove file from manifest
        removeFile(*m_pImpl, xPart);

    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::removeContentOrStylesFile: exception"),
            *this, uno::makeAny(e));
    }
}

void SAL_CALL DocumentMetadataAccess::loadMetadataFromStorage(
    const uno::Reference< embed::XStorage > & i_xStorage,
    const uno::Reference<rdf::XURI> & i_xBaseURI,
    const uno::Reference<task::XInteractionHandler> & i_xHandler)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    lang::WrappedTargetException)
{
    if (!i_xStorage.is()) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: "
            "storage is null"), *this, 0);
    }
    if (!i_xBaseURI.is()) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: "
            "base URI is null"), *this, 1);
    }
    const ::rtl::OUString baseURI( i_xBaseURI->getStringValue());
    if (baseURI.indexOf('#') >= 0) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: "
            "base URI not absolute"), *this, 1);
    }
    if (!baseURI.getLength() || !baseURI.endsWithAsciiL("/", 1)) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromStorage: "
            "base URI does not end with slash"), *this, 1);
    }

    initLoading(*m_pImpl, i_xStorage, i_xBaseURI, i_xHandler);

    std::set< ::rtl::OUString > StgFiles;
    collectFilesFromStorage(i_xStorage,
        ::rtl::OUString::createFromAscii(""), StgFiles);

    std::vector< ::rtl::OUString > MfstMetadataFiles;

    try {
        const ::std::vector< uno::Reference< rdf::XURI > > parts(
            getAllParts(*m_pImpl) );
        const uno::Reference<rdf::XURI> xContentFile(
            getURI<rdf::URIs::ODF_CONTENTFILE>(m_pImpl->m_xContext));
        const uno::Reference<rdf::XURI> xStylesFile(
            getURI<rdf::URIs::ODF_STYLESFILE>(m_pImpl->m_xContext));
        const uno::Reference<rdf::XURI> xMetadataFile(
            getURI<rdf::URIs::PKG_METADATAFILE>(m_pImpl->m_xContext));
        const sal_Int32 len( baseURI.getLength() );
        const ::rtl::OUString manifest (
                ::rtl::OUString::createFromAscii(s_manifest));
        for (::std::vector< uno::Reference< rdf::XURI > >::const_iterator it
                = parts.begin();
                it != parts.end(); ++it) {
            const ::rtl::OUString name((*it)->getStringValue());
            if (!name.match(baseURI)) {
                OSL_TRACE("loadMetadataFromStorage: graph not in document: %s",
                    ::rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8)
                    .getStr());
                continue;
            }
            const ::rtl::OUString relName( name.copy(len) );
            if (relName == manifest) {
                OSL_TRACE("loadMetadataFromStorage: "
                    "found ourselves a recursive manifest!");
                continue;
            }
            // remove found items from StgFiles
            StgFiles.erase(relName);
            if (isContentFile(relName)) {
                if (!isPartOfType(*m_pImpl, *it, xContentFile)) {
                    const uno::Reference <rdf::XURI> xName(
                        getURIForStream(*m_pImpl, relName) );
                    // add missing type statement
                    m_pImpl->m_xManifest->addStatement(xName.get(),
                        getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext),
                        xContentFile.get());
                }
            } else if (isStylesFile(relName)) {
                if (!isPartOfType(*m_pImpl, *it, xStylesFile)) {
                    const uno::Reference <rdf::XURI> xName(
                        getURIForStream(*m_pImpl, relName) );
                    // add missing type statement
                    m_pImpl->m_xManifest->addStatement(xName.get(),
                        getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext),
                        xStylesFile.get());
                }
            } else if (isReservedFile(relName)) {
                OSL_TRACE("loadMetadataFromStorage: "
                    "reserved file name in manifest");
            } else {
                if (isPartOfType(*m_pImpl, *it, xMetadataFile)) {
                    MfstMetadataFiles.push_back(relName);
                }
                // do not add statement for MetadataFile; it could be
                // something else! just ignore it...
            }
        }
    } catch (uno::RuntimeException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "DocumentMetadataAccess::loadMetadataFromStorage: "
                "exception"), *this, uno::makeAny(e));
    }

    std::for_each(StgFiles.begin(), StgFiles.end(),
        boost::bind(addContentOrStylesFileImpl, boost::ref(*m_pImpl), _1));

    std::for_each(MfstMetadataFiles.begin(), MfstMetadataFiles.end(),
        boost::bind(importFile, boost::ref(*m_pImpl),
            i_xStorage, baseURI, i_xHandler, _1));
}

void SAL_CALL DocumentMetadataAccess::storeMetadataToStorage(
    const uno::Reference< embed::XStorage > & i_xStorage)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    lang::WrappedTargetException)
{
    if (!i_xStorage.is()) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::storeMetadataToStorage: "
            "storage is null"), *this, 0);
    }

    // export manifest
    const ::rtl::OUString manifest (
            ::rtl::OUString::createFromAscii(s_manifest));
    const uno::Reference <rdf::XURI> xManifest(
        getURIForStream(*m_pImpl, manifest) );
    const ::rtl::OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() );
    try {
        writeStream(*m_pImpl, i_xStorage, xManifest, manifest, baseURI);
    } catch (uno::RuntimeException &) {
        throw;
    } catch (io::IOException & e) {
        throw lang::WrappedTargetException( ::rtl::OUString::createFromAscii(
            "storeMetadataToStorage: IO exception"), *this, uno::makeAny(e));
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "storeMetadataToStorage: exception"), *this, uno::makeAny(e));
    }

    // export metadata streams
    try {
        const uno::Sequence<uno::Reference<rdf::XURI> > graphs(
            m_pImpl->m_xRepository->getGraphNames());
        const sal_Int32 len( baseURI.getLength() );
        for (sal_Int32 i = 0; i < graphs.getLength(); ++i) {
            const uno::Reference<rdf::XURI> xName(graphs[i]);
            const ::rtl::OUString name(xName->getStringValue());
            if (!name.match(baseURI)) {
                OSL_TRACE("storeMetadataToStorage: graph not in document: %s",
                    ::rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8)
                    .getStr());
                continue;
            }
            const ::rtl::OUString relName( name.copy(len) );
            if (relName == manifest) {
                continue;
            }
            if (!isFileNameValid(relName) || isReservedFile(relName)) {
                OSL_TRACE("storeMetadataToStorage: invalid file name: %s",
                    ::rtl::OUStringToOString(relName, RTL_TEXTENCODING_UTF8)
                    .getStr());
                continue;
            }
            try {
                writeStream(*m_pImpl, i_xStorage, xName, relName, baseURI);
            } catch (uno::RuntimeException &) {
                throw;
            } catch (io::IOException & e) {
                throw lang::WrappedTargetException(
                    ::rtl::OUString::createFromAscii(
                        "storeMetadataToStorage: IO exception"),
                    *this, uno::makeAny(e));
            } catch (uno::Exception & e) {
                throw lang::WrappedTargetRuntimeException(
                    ::rtl::OUString::createFromAscii(
                        "storeMetadataToStorage: exception"),
                    *this, uno::makeAny(e));
            }
        }
    } catch (rdf::RepositoryException & e) {
        throw lang::WrappedTargetRuntimeException(
            ::rtl::OUString::createFromAscii(
                "storeMetadataToStorage: exception"), *this, uno::makeAny(e));
    }
}

void SAL_CALL
DocumentMetadataAccess::loadMetadataFromMedium(
    const uno::Sequence< beans::PropertyValue > & i_rMedium)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    lang::WrappedTargetException)
{
    uno::Reference<io::XInputStream> xIn;
    ::comphelper::MediaDescriptor md(i_rMedium);
    ::rtl::OUString URL;
    md[ ::comphelper::MediaDescriptor::PROP_URL() ] >>= URL;
    ::rtl::OUString BaseURL;
    md[ ::comphelper::MediaDescriptor::PROP_DOCUMENTBASEURL() ] >>= BaseURL;
    if (md.addInputStream()) {
        md[ ::comphelper::MediaDescriptor::PROP_INPUTSTREAM() ] >>= xIn;
    }
    if (!xIn.is() && URL.equalsAscii("")) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromMedium: "
            "inalid medium: no URL, no input stream"), *this, 0);
    }
    uno::Reference<embed::XStorage> xStorage;
    try {
        const uno::Reference<lang::XMultiServiceFactory> xMsf (
            m_pImpl->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW);
        if (xIn.is()) {
            xStorage = ::comphelper::OStorageHelper::GetStorageFromInputStream(
                            xIn, xMsf);
        } else { // fallback to url
            xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2(
                            URL, embed::ElementModes::READ, xMsf);
        }
    } catch (uno::RuntimeException &) {
        throw;
    } catch (io::IOException &) {
        throw;
    } catch (uno::Exception & e) {
        throw lang::WrappedTargetException(
                ::rtl::OUString::createFromAscii(
                    "DocumentMetadataAccess::loadMetadataFromMedium: "
                    "exception"), *this, uno::makeAny(e));
    }
    if (!xStorage.is()) {
        throw uno::RuntimeException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::loadMetadataFromMedium: "
            "cannot get Storage"), *this);
    }
    uno::Reference<rdf::XURI> xBaseURI;
    try {
        xBaseURI = createBaseURI(m_pImpl->m_xContext, xStorage, BaseURL);
    } catch (uno::Exception &) {
        // fall back to URL
        try {
            xBaseURI = createBaseURI(m_pImpl->m_xContext, xStorage, URL);
        } catch (uno::Exception &) {
            OSL_ENSURE(false, "cannot create base URI");
        }
    }
    uno::Reference<task::XInteractionHandler> xIH;
    md[ ::comphelper::MediaDescriptor::PROP_INTERACTIONHANDLER() ] >>= xIH;
    loadMetadataFromStorage(xStorage, xBaseURI, xIH);
}

void SAL_CALL
DocumentMetadataAccess::storeMetadataToMedium(
    const uno::Sequence< beans::PropertyValue > & i_rMedium)
throw (uno::RuntimeException, lang::IllegalArgumentException,
    lang::WrappedTargetException)
{
    ::comphelper::MediaDescriptor md(i_rMedium);
    ::rtl::OUString URL;
    md[ ::comphelper::MediaDescriptor::PROP_URL() ] >>= URL;
    if (URL.equalsAscii("")) {
        throw lang::IllegalArgumentException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::storeMetadataToMedium: "
            "invalid medium: no URL"), *this, 0);
    }

    SfxMedium aMedium(i_rMedium);
    uno::Reference<embed::XStorage> xStorage(aMedium.GetOutputStorage());

    bool sfx(false);
    if (xStorage.is()) {
        sfx = true;
    } else {
        const uno::Reference<lang::XMultiServiceFactory> xMsf (
            m_pImpl->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW);
        xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2(
                        URL, embed::ElementModes::WRITE, xMsf);
    }

    if (!xStorage.is()) {
        throw uno::RuntimeException(::rtl::OUString::createFromAscii(
            "DocumentMetadataAccess::storeMetadataToMedium: "
            "cannot get Storage"), *this);
    }
    // set MIME type of the storage
    ::comphelper::MediaDescriptor::const_iterator iter
        = md.find(::comphelper::MediaDescriptor::PROP_MEDIATYPE());
    if (iter != md.end()) {
        uno::Reference< beans::XPropertySet > xProps(xStorage,
            uno::UNO_QUERY_THROW);
        try {
            // this is NOT supported in FileSystemStorage
            xProps->setPropertyValue(
                ::comphelper::MediaDescriptor::PROP_MEDIATYPE(),
                iter->second);
        } catch (uno::Exception &) { }
    }
    storeMetadataToStorage(xStorage);

    if (sfx) {
        const sal_Bool bOk = aMedium.Commit();
        aMedium.Close();
        if ( !bOk ) {
            sal_uInt32 nError = aMedium.GetError();
            if ( nError == ERRCODE_NONE ) {
                nError = ERRCODE_IO_GENERAL;
            }
            task::ErrorCodeIOException ex( ::rtl::OUString(),
                    uno::Reference< uno::XInterface >(), nError);
            throw lang::WrappedTargetException(::rtl::OUString(), *this,
                    uno::makeAny(ex));
        }
    }
}

} // namespace sfx2