externalrefmgr.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include "address.hxx"
#include "document.hxx"
#include <sfx2/objsh.hxx>
#include <sfx2/lnkbase.hxx>
#include <tools/time.hxx>
#include <vcl/timer.hxx>
#include <svl/zforlist.hxx>
#include <svl/lstner.hxx>
#include "types.hxx"
#include "rangelst.hxx"
#include <osl/mutex.hxx>
#include <formula/types.hxx>
#include <tools/solar.h>
 
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <set>
#include <o3tl/sorted_vector.hxx>
#include <formula/ExternalReferenceHelper.hxx>
 
class ScTokenArray;
namespace weld { class Window; }
 
class ScFormulaCell;
 
namespace sc {
 
class ColumnSpanSet;
 
}
 
class ScExternalRefLink final : public ::sfx2::SvBaseLink
{
public:
    ScExternalRefLink(ScDocument& rDoc, sal_uInt16 nFileId);
    virtual ~ScExternalRefLink() override;
 
    virtual void Closed() override;
    virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(
        const OUString& rMimeType, const css::uno::Any & rValue) override;
    virtual void Edit(weld::Window* pParent, const Link<SvBaseLink&,void>& rEndEditHdl) override;
 
    void SetDoRefresh(bool b);
 
private:
    ScExternalRefLink() = delete;
    ScExternalRefLink(const ScExternalRefLink&) = delete;
 
    sal_uInt16  mnFileId;
    ScDocument& mrDoc;
    bool        mbDoRefresh;
};
 
class ScExternalRefCache
{
public:
    typedef ::formula::FormulaTokenRef          TokenRef;
    typedef std::shared_ptr<ScTokenArray>   TokenArrayRef;
 
    struct TableName
    {
        OUString maUpperName;
        OUString maRealName;
 
        explicit TableName(OUString aUpper, OUString aReal);
    };
 
    struct CellFormat
    {
        bool      mbIsSet;
        SvNumFormatType mnType;
        sal_uLong mnIndex;
 
        explicit CellFormat();
    };
 
private:
    struct Cell
    {
        TokenRef   mxToken;
        sal_uLong  mnFmtIndex;
    };
    typedef std::unordered_map<SCCOL, Cell>            RowDataType;
    typedef std::unordered_map<SCROW, RowDataType>     RowsDataType;
 
public:
    class Table
    {
    public:
 
        Table();
        ~Table();
 
        void clear();
 
        SC_DLLPUBLIC void setCell(SCCOL nCol, SCROW nRow, TokenRef const & pToken, sal_uLong nFmtIndex = 0, bool bSetCacheRange = true);
        SC_DLLPUBLIC TokenRef getCell(SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex = nullptr) const;
        bool hasRow( SCROW nRow ) const;
        void setReferenced( bool bReferenced );
        bool isReferenced() const;
        void getAllRows(::std::vector<SCROW>& rRows, SCROW nLow, SCROW nHigh) const;
        void getAllRows(::std::vector<SCROW>& rRows) const;
        SC_DLLPUBLIC ::std::pair< SCROW, SCROW > getRowRange() const;
        void getAllCols(SCROW nRow, ::std::vector<SCCOL>& rCols, SCCOL nLow, SCCOL nHigh) const;
        void getAllCols(SCROW nRow, ::std::vector<SCCOL>& rCols) const;
        SC_DLLPUBLIC ::std::pair< SCCOL, SCCOL > getColRange( SCROW nRow ) const;
        void getAllNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
        bool isRangeCached(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;
 
        void setCachedCell(SCCOL nCol, SCROW nRow);
        void setCachedCellRange(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
 
        SC_DLLPUBLIC void setWholeTableCached();
    private:
        bool isInCachedRanges(SCCOL nCol, SCROW nRow) const;
        TokenRef getEmptyOrNullToken(SCCOL nCol, SCROW nRow) const;
        template< typename P >
        void getAllRows(::std::vector<SCROW>& rRows, P predicate) const;
        template< typename P >
        void getAllCols(SCROW nRow, ::std::vector<SCCOL>& rCols, P predicate) const;
 
    private:
        RowsDataType                    maRows;
        ScRangeList                     maCachedRanges;
        bool                            mbReferenced;
    };
 
    typedef std::shared_ptr<Table> TableTypeRef;
    typedef std::unordered_map< OUString, size_t>
        TableNameIndexMap;
 
    ScExternalRefCache(const ScDocument& rDoc);
    ~ScExternalRefCache();
 
    const OUString* getRealTableName(sal_uInt16 nFileId, const OUString& rTabName) const;
    const OUString* getRealRangeName(sal_uInt16 nFileId, const OUString& rRangeName) const;
 
    ScExternalRefCache::TokenRef getCellData(
        sal_uInt16 nFileId, const OUString& rTabName, SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex);
 
    ScExternalRefCache::TokenArrayRef getCellRangeData(
        sal_uInt16 nFileId, const OUString& rTabName, const ScRange& rRange);
 
    ScExternalRefCache::TokenArrayRef getRangeNameTokens(sal_uInt16 nFileId, const OUString& rName);
    void setRangeNameTokens(sal_uInt16 nFileId, const OUString& rName, TokenArrayRef pArray);
    bool isValidRangeName(sal_uInt16 nFileId, const OUString& rName) const;
    void setRangeName(sal_uInt16 nFileId, const OUString& rName);
 
    void setCellData(sal_uInt16 nFileId, const OUString& rTabName,
                     SCCOL nCol, SCROW nRow, TokenRef const & pToken, sal_uLong nFmtIndex);
 
    struct SingleRangeData
    {
        OUString maTableName;
        ScMatrixRef mpRangeData;
    };
    void setCellRangeData(sal_uInt16 nFileId, const ScRange& rRange, const ::std::vector<SingleRangeData>& rData,
                          const TokenArrayRef& pArray);
 
    bool isDocInitialized(sal_uInt16 nFileId);
    void initializeDoc(sal_uInt16 nFileId, const ::std::vector<OUString>& rTabNames, const OUString& rBaseName);
    OUString getTableName(sal_uInt16 nFileId, size_t nCacheId) const;
    void getAllTableNames(sal_uInt16 nFileId, ::std::vector<OUString>& rTabNames) const;
    SCTAB getTabSpan( sal_uInt16 nFileId, const OUString& rStartTabName, const OUString& rEndTabName ) const;
    void getAllNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
 
    bool setCacheDocReferenced( sal_uInt16 nFileId );
 
    bool setCacheTableReferenced( sal_uInt16 nFileId, const OUString& rTabName, size_t nSheets );
    void setAllCacheTableReferencedStati( bool bReferenced );
    bool areAllCacheTablesReferenced() const { return maReferenced.mbAllReferenced;}
 
    void getAllCachedDataSpans( const ScDocument& rSrcDoc, sal_uInt16 nFileId, sc::ColumnSpanSet& rSet ) const;
 
    bool getSrcDocTable( const ScDocument& rSrcDoc, const OUString& rTabName, SCTAB& rTab, sal_uInt16 nFileId ) const;
 
private:
    struct ReferencedStatus
    {
        struct DocReferenced
        {
            ::std::vector<bool> maTables;
            bool                mbAllTablesReferenced;
            // Initially, documents have no tables but all referenced.
            DocReferenced() : mbAllTablesReferenced(true) {}
        };
        typedef ::std::vector<DocReferenced> DocReferencedVec;
 
        DocReferencedVec maDocs;
        bool             mbAllReferenced;
 
                    ReferencedStatus();
        void        reset( size_t nDocs );
        void        checkAllDocs();
 
    } maReferenced;
    void addCacheTableToReferenced( sal_uInt16 nFileId, size_t nIndex );
    void addCacheDocToReferenced( sal_uInt16 nFileId );
public:
 
    ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const;
    ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, const OUString& rTabName, bool bCreateNew,
            size_t* pnIndex, const OUString* pExtUrl);
 
    void clearCache(sal_uInt16 nFileId);
 
    void clearCacheTables(sal_uInt16 nFileId);
 
    // Get the doc used to pass to methods that need an ScDocument in order to do row/col validation
    const ScDocument& getDoc() const { return mrDoc; }
 
private:
    struct RangeHash
    {
        size_t operator()(const ScRange& rRange) const
        {
            const ScAddress& s = rRange.aStart;
            const ScAddress& e = rRange.aEnd;
            size_t hash = 17;
            hash = hash * 37 + s.Tab();
            hash = hash * 37 + s.Col();
            hash = hash * 37 + s.Row();
            hash = hash * 37 + e.Tab();
            hash = hash * 37 + e.Col();
            hash = hash * 37 + e.Row();
            return hash;
        }
    };
 
    typedef std::unordered_map<OUString, TokenArrayRef> RangeNameMap;
    typedef std::unordered_map<ScRange, TokenArrayRef, RangeHash> RangeArrayMap;
    typedef std::unordered_map<OUString, OUString> NamePairMap;
 
    struct DocItem
    {
        ::std::vector<TableTypeRef> maTables;
        ::std::vector<TableName>    maTableNames;
        TableNameIndexMap           maTableNameIndex;
        RangeNameMap                maRangeNames;
        RangeArrayMap               maRangeArrays;
        NamePairMap                 maRealRangeNameMap;
 
        OUString                    maSingleTableNameAlias;
 
        bool mbInitFromSource;
 
        DocItem() : mbInitFromSource(false) {}
 
        TableNameIndexMap::const_iterator findTableNameIndex( const OUString& rTabName ) const;
        bool getTableDataIndex( const OUString& rTabName, size_t& rIndex ) const;
        bool getSingleTableNameAlternative( OUString& rTabName ) const;
    };
    typedef std::unordered_map<sal_uInt16, DocItem>  DocDataType;
    DocItem* getDocItem(sal_uInt16 nFileId) const;
 
private:
    mutable osl::Mutex maMtxDocs;
    mutable DocDataType maDocs;
    const ScDocument& mrDoc;
};
 
class SC_DLLPUBLIC ScExternalRefManager final : public formula::ExternalReferenceHelper, public SfxListener
{
public:
 
    typedef std::set<ScFormulaCell*>                      RefCellSet;
    typedef std::unordered_map<sal_uInt16, RefCellSet>         RefCellMap;
 
    enum LinkUpdateType { LINK_MODIFIED, LINK_BROKEN, OH_NO_WE_ARE_GOING_TO_DIE };
 
    class SAL_DLLPRIVATE LinkListener
    {
    public:
        LinkListener();
        virtual ~LinkListener() COVERITY_NOEXCEPT_FALSE = 0;
        virtual void notify(sal_uInt16 nFileId, LinkUpdateType eType) = 0;
    };
 
    class SC_DLLPUBLIC ApiGuard
    {
    public:
        ApiGuard(const ScDocument& rDoc);
        ~ApiGuard();
    private:
        ScExternalRefManager* mpMgr;
        bool mbOldInteractionEnabled;
    };
 
private:
    struct SrcShell
    {
        SfxObjectShellRef   maShell;
        tools::Time         maLastAccess;
 
        SrcShell() : maLastAccess( tools::Time::SYSTEM ) {}
    };
 
    typedef std::unordered_map<sal_uInt16, SrcShell>           DocShellMap;
    typedef std::unordered_map<sal_uInt16, bool>               LinkedDocMap;
 
    typedef std::unordered_map<sal_uInt16, SvNumberFormatterMergeMap> NumFmtMap;
 
    typedef o3tl::sorted_vector<LinkListener*>                     LinkListeners;
    typedef std::unordered_map<sal_uInt16, LinkListeners>          LinkListenerMap;
 
public:
    struct SAL_DLLPRIVATE SrcFileData
    {
        OUString maFileName;      
        OUString maRealFileName;  
        OUString maRelativeName;
        OUString maFilterName;
        OUString maFilterOptions;
 
        void maybeCreateRealFileName(std::u16string_view rOwnDocName);
    };
 
public:
    explicit ScExternalRefManager(ScDocument& rDoc);
    virtual ~ScExternalRefManager() override;
 
    virtual OUString getCacheTableName(sal_uInt16 nFileId, size_t nTabIndex) const override;
 
    ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const;
 
    ScExternalRefCache::TableTypeRef getCacheTable(sal_uInt16 nFileId, const OUString& rTabName, bool bCreateNew,
            size_t* pnIndex = nullptr, const OUString* pExtUrl = nullptr);
 
    void getAllCachedTableNames(sal_uInt16 nFileId, ::std::vector<OUString>& rTabNames) const;
 
    SCTAB getCachedTabSpan(
        sal_uInt16 nFileId, const OUString& rStartTabName, const OUString& rEndTabName) const;
 
    void getAllCachedNumberFormats(::std::vector<sal_uInt32>& rNumFmts) const;
 
    sal_uInt16 getExternalFileCount() const;
 
    void markUsedByLinkListeners();
 
    void markUsedExternalRefCells();
 
    bool setCacheTableReferenced( sal_uInt16 nFileId, const OUString& rTabName, size_t nSheets );
    void setAllCacheTableReferencedStati( bool bReferenced );
 
    bool isInReferenceMarking() const   { return mbInReferenceMarking; }
 
    void storeRangeNameTokens(sal_uInt16 nFileId, const OUString& rName, const ScTokenArray& rArray);
 
    ScExternalRefCache::TokenRef getSingleRefToken(
        sal_uInt16 nFileId, const OUString& rTabName, const ScAddress& rCell,
        const ScAddress* pCurPos, SCTAB* pTab, ScExternalRefCache::CellFormat* pFmt = nullptr);
 
    ScExternalRefCache::TokenArrayRef getDoubleRefTokens(
        sal_uInt16 nFileId, const OUString& rTabName, const ScRange& rRange, const ScAddress* pCurPos);
 
    ScExternalRefCache::TokenArrayRef getRangeNameTokens(
        sal_uInt16 nFileId, const OUString& rName, const ScAddress* pCurPos = nullptr);
 
    bool isValidRangeName(sal_uInt16 nFileId, const OUString& rName);
 
    OUString getOwnDocumentName() const;
    bool isOwnDocument(std::u16string_view rFile) const;
 
    void convertToAbsName(OUString& rFile) const;
    sal_uInt16 getExternalFileId(const OUString& rFile);
 
    const OUString* getExternalFileName(sal_uInt16 nFileId, bool bForceOriginal = false);
 
    sal_uInt16 convertFileIdToUsedFileId(sal_uInt16 nFileId);
    void setSkipUnusedFileIds(std::vector<sal_uInt16>& pExternFileIds);
    void disableSkipUnusedFileIds();
 
    std::vector<OUString> getAllCachedExternalFileNames() const;
 
    bool hasExternalFile(sal_uInt16 nFileId) const;
    bool hasExternalFile(const OUString& rFile) const;
    const SrcFileData* getExternalFileData(sal_uInt16 nFileId) const;
 
    const OUString* getRealTableName(sal_uInt16 nFileId, const OUString& rTabName) const;
    const OUString* getRealRangeName(sal_uInt16 nFileId, const OUString& rRangeName) const;
    void clearCache(sal_uInt16 nFileId);
    bool refreshSrcDocument(sal_uInt16 nFileId);
    void breakLink(sal_uInt16 nFileId);
    void switchSrcFile(sal_uInt16 nFileId, const OUString& rNewFile, const OUString& rNewFilter);
 
    void setRelativeFileName(sal_uInt16 nFileId, const OUString& rRelUrl);
 
    void setFilterData(sal_uInt16 nFileId, const OUString& rFilterName, const OUString& rOptions);
 
    void clear();
 
    bool hasExternalData() const;
 
    void resetSrcFileData(const OUString& rBaseFileUrl);
 
    void updateAbsAfterLoad();
 
    void removeRefCell(ScFormulaCell* pCell);
 
    void addLinkListener(sal_uInt16 nFileId, LinkListener* pListener);
 
    void removeLinkListener(sal_uInt16 nFileId, LinkListener* pListener);
 
    void removeLinkListener(LinkListener* pListener);
 
    void notifyAllLinkListeners(sal_uInt16 nFileId, LinkUpdateType eType);
 
    bool isFileLoadable(const OUString& rFile) const;
 
    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
 
    bool containsUnsavedReferences() const { return !maUnsavedDocShells.empty(); }
 
    void insertRefCell(sal_uInt16 nFileId, const ScAddress& rCell);
    void insertRefCellFromTemplate( ScFormulaCell* pTemplateCell, ScFormulaCell* pCell );
 
    bool hasCellExternalReference(const ScAddress& rCell);
 
    void enableDocTimer( bool bEnable );
 
    void addFilesToLinkManager();
 
private:
    ScExternalRefManager(const ScExternalRefManager&) = delete;
 
    void refreshAllRefCells(sal_uInt16 nFileId);
 
    void fillCellFormat(sal_uLong nFmtIndex, ScExternalRefCache::CellFormat* pFmt) const;
 
    bool getSrcDocTable( const ScDocument& rSrcDoc, const OUString& rTabName, SCTAB& rTab, sal_uInt16 nFileId ) const;
 
    ScExternalRefCache::TokenRef getSingleRefTokenFromSrcDoc(
        sal_uInt16 nFileId, ScDocument& rSrcDoc, const ScAddress& rPos,
        ScExternalRefCache::CellFormat* pFmt);
 
    ScExternalRefCache::TokenArrayRef getDoubleRefTokensFromSrcDoc(
        const ScDocument& rSrcDoc, const OUString& rTabName, ScRange& rRange,
        ::std::vector<ScExternalRefCache::SingleRangeData>& rCacheData);
 
    static ScExternalRefCache::TokenArrayRef getRangeNameTokensFromSrcDoc(
        sal_uInt16 nFileId, const ScDocument& rSrcDoc, OUString& rName);
 
    ScDocument* getInMemorySrcDocument(sal_uInt16 nFileId);
    ScDocument* getSrcDocument(sal_uInt16 nFileId);
    SfxObjectShellRef loadSrcDocument(sal_uInt16 nFileId, OUString& rFilter);
 
    ScDocument& cacheNewDocShell( sal_uInt16 nFileId, SrcShell& rSrcShell );
 
    void maybeLinkExternalFile( sal_uInt16 nFileId, bool bDeferFilterDetection = false );
 
    void maybeCreateRealFileName(sal_uInt16 nFileId);
 
    void purgeStaleSrcDocument(sal_Int32 nTimeOut);
 
    sal_uInt32 getMappedNumberFormat(sal_uInt16 nFileId, sal_uInt32 nNumFmt, const ScDocument& rSrcDoc);
 
    void transformUnsavedRefToSavedRef( SfxObjectShell* pShell );
 
private:
    ScDocument& mrDoc;
 
    ScExternalRefCache maRefCache;
 
    DocShellMap maDocShells;
 
    DocShellMap maUnsavedDocShells;
 
    LinkedDocMap maLinkedDocs;
 
    RefCellMap maRefCells;
 
    LinkListenerMap maLinkListeners;
 
    NumFmtMap maNumFormatMap;
 
    std::vector<SrcFileData> maSrcFiles;
 
    bool mbInReferenceMarking:1;
 
    bool mbUserInteractionEnabled:1;
 
    bool mbSkipUnusedFileIds = false;
    std::vector<sal_uInt16> maConvertFileIdToUsedFileId;
 
    bool mbDocTimerEnabled:1;
 
    AutoTimer maSrcDocTimer;
    DECL_DLLPRIVATE_LINK(TimeOutHdl, Timer*, void);
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */