pivotcachebuffer.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 <com/sun/star/util/DateTime.hpp>
#include <oox/helper/containerhelper.hxx>
#include <oox/helper/refvector.hxx>
#include "workbookhelper.hxx"

namespace oox { class AttributeList; }
namespace oox { class SequenceInputStream; }

namespace com::sun::star {
    namespace sheet { class XDataPilotField; }
}

namespace oox::core { class Relations; }

class ScDPSaveDimension;
class ScDPObject;
class DateTime;

namespace oox::xls {

class WorksheetHelper;

typedef ::std::pair< sal_Int32, OUString > IdCaptionPair;
typedef ::std::vector< IdCaptionPair > IdCaptionPairList;

class PivotCacheItem
{
public:
    explicit            PivotCacheItem();

    void                readString( const AttributeList& rAttribs );
    void                readNumeric( const AttributeList& rAttribs );
    void                readDate( const AttributeList& rAttribs );
    void                readBool( const AttributeList& rAttribs );
    void                readError( const AttributeList& rAttribs );
    void                readIndex( const AttributeList& rAttribs );

    void                readString( SequenceInputStream& rStrm );
    void                readDouble( SequenceInputStream& rStrm );
    void                readDate( SequenceInputStream& rStrm );
    void                readBool( SequenceInputStream& rStrm );
    void                readError(SequenceInputStream& rStrm, const UnitConverter& rUnitConverter);
    void                readIndex( SequenceInputStream& rStrm );

    sal_Int32    getType() const { return mnType; }
    const css::uno::Any& getValue() const { return maValue; }
    OUString     getName() const;

    OUString     getFormattedName(const ScDPSaveDimension& rSaveDim, ScDPObject* pObj, const DateTime& rNullDate) const;
    bool         isUnused() const { return mbUnused; }

private:
friend class PivotCacheItemList;
    // #FIXME hack Sets the value of this item to the given string ( and overwrites type if necessary
    void                setStringValue( const OUString& sName );
    css::uno::Any       maValue;     
    sal_Int32           mnType;             
    bool                mbUnused;
};

class PivotCacheItemList : public WorkbookHelper
{
public:
    explicit            PivotCacheItemList( const WorkbookHelper& rHelper );

    void                importItem( sal_Int32 nElement, const AttributeList& rAttribs );
    void                importItem( sal_Int32 nRecId, SequenceInputStream& rStrm );

    bool         empty() const { return maItems.empty(); }
    size_t       size() const { return maItems.size(); }

    const PivotCacheItem* getCacheItem( sal_Int32 nItemIdx ) const;
    void                getCacheItemNames( ::std::vector< OUString >& orItemNames ) const;
    void                applyItemCaptions( const IdCaptionPairList& vCaptions );

private:
    PivotCacheItem&     createItem();
    void                importArray( SequenceInputStream& rStrm );

private:
    std::vector< PivotCacheItem >  maItems;            
};

struct PCFieldModel
{
    OUString     maName;             
    OUString     maCaption;          
    OUString     maPropertyName;     
    OUString     maFormula;          
    sal_Int32           mnNumFmtId;         
    sal_Int32           mnSqlType;          
    sal_Int32           mnHierarchy;        
    sal_Int32           mnLevel;            
    sal_Int32           mnMappingCount;     
    bool                mbDatabaseField;    
    bool                mbServerField;      
    bool                mbUniqueList;       
    bool                mbMemberPropField;  

    explicit            PCFieldModel();
};

struct PCSharedItemsModel
{
    bool                mbHasSemiMixed;     
    bool                mbHasNonDate;       
    bool                mbHasDate;          
    bool                mbHasString;        
    bool                mbHasBlank;         
    bool                mbHasMixed;         
    bool                mbIsNumeric;        
    bool                mbIsInteger;        
    bool                mbHasLongText;      

    explicit            PCSharedItemsModel();
};

struct PCFieldGroupModel
{
    css::util::DateTime maStartDate;   
    css::util::DateTime maEndDate;     
    double              mfStartValue;       
    double              mfEndValue;         
    double              mfInterval;         
    sal_Int32           mnParentField;      
    sal_Int32           mnBaseField;        
    sal_Int32           mnGroupBy;          
    bool                mbRangeGroup;       
    bool                mbDateGroup;        
    bool                mbAutoStart;        
    bool                mbAutoEnd;          
    OUString            msFinalGroupName ;  


    explicit            PCFieldGroupModel();

    void                setBiffGroupBy( sal_uInt8 nGroupBy );
};

struct PivotCacheGroupItem
{
    OUString     maOrigName;
    OUString     maGroupName;

    explicit     PivotCacheGroupItem( const OUString& rItemName ) :
                            maOrigName( rItemName ), maGroupName( rItemName ) {}
};

typedef ::std::vector< PivotCacheGroupItem > PivotCacheGroupItemVector;

class PivotCacheField : public WorkbookHelper
{
public:
    explicit            PivotCacheField( const WorkbookHelper& rHelper, bool bIsDatabaseField );

    void                importCacheField( const AttributeList& rAttribs );
    void                importSharedItems( const AttributeList& rAttribs );
    void                importSharedItem( sal_Int32 nElement, const AttributeList& rAttribs );
    void                importFieldGroup( const AttributeList& rAttribs );
    void                importRangePr( const AttributeList& rAttribs );
    void                importDiscretePrItem( sal_Int32 nElement, const AttributeList& rAttribs );
    void                importGroupItem( sal_Int32 nElement, const AttributeList& rAttribs );

    void                importPCDField( SequenceInputStream& rStrm );
    void                importPCDFSharedItems( SequenceInputStream& rStrm );
    void                importPCDFSharedItem( sal_Int32 nRecId, SequenceInputStream& rStrm );
    void                importPCDFieldGroup( SequenceInputStream& rStrm );
    void                importPCDFRangePr( SequenceInputStream& rStrm );
    void                importPCDFDiscretePrItem( sal_Int32 nRecId, SequenceInputStream& rStrm );
    void                importPCDFGroupItem( sal_Int32 nRecId, SequenceInputStream& rStrm );

    void                applyItemCaptions( const IdCaptionPairList& vCaptions );

    bool         isDatabaseField() const { return maFieldModel.mbDatabaseField; }

    bool         hasSharedItems() const { return !maSharedItems.empty(); }
    bool         hasGroupItems() const { return !maGroupItems.empty(); }
    bool         hasNumericGrouping() const { return maFieldGroupModel.mbRangeGroup && !maFieldGroupModel.mbDateGroup; }
    bool         hasDateGrouping() const { return maFieldGroupModel.mbRangeGroup && maFieldGroupModel.mbDateGroup; }
    bool         hasParentGrouping() const { return maFieldGroupModel.mnParentField >= 0; }

    const OUString& getName() const { return maFieldModel.maName; }
    sal_Int32    getParentGroupField() const { return maFieldGroupModel.mnParentField; }
    sal_Int32    getGroupBaseField() const { return maFieldGroupModel.mnBaseField; }
    const OUString& getFinalGroupName() const { return maFieldGroupModel.msFinalGroupName; }
    void            setFinalGroupName(const OUString& rFinalGroupName) { maFieldGroupModel.msFinalGroupName = rFinalGroupName; }

    const PivotCacheItem* getCacheItem( sal_Int32 nItemIdx ) const;
    void                getCacheItemNames( ::std::vector< OUString >& orItemNames ) const;
    const PivotCacheItemList&  getCacheItems() const;

    void                convertNumericGrouping(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxDPField ) const;
    OUString     createDateGroupField(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField ) const;
    OUString     createParentGroupField(
                            const css::uno::Reference< css::sheet::XDataPilotField >& rxBaseDPField,
                            const PivotCacheField& rBaseCacheField,
                            PivotCacheGroupItemVector& orItemNames ) const;

    void                writeSourceHeaderCell( const WorksheetHelper& rSheetHelper,
                            sal_Int32 nCol, sal_Int32 nRow ) const;
    void                writeSourceDataCell( const WorksheetHelper& rSheetHelper,
                            sal_Int32 nCol, sal_Int32 nRow,
                            const PivotCacheItem& rItem ) const;

    void                importPCRecordItem( SequenceInputStream& rStrm,
                            const WorksheetHelper& rSheetHelper, sal_Int32 nCol, sal_Int32 nRow ) const;

private:
    static void         writeItemToSourceDataCell( const WorksheetHelper& rSheetHelper,
                            sal_Int32 nCol, sal_Int32 nRow, const PivotCacheItem& rItem );
    void                writeSharedItemToSourceDataCell( const WorksheetHelper& rSheetHelper,
                            sal_Int32 nCol, sal_Int32 nRow, sal_Int32 nItemIdx ) const;

private:
    typedef ::std::vector< sal_Int32 > IndexVector;

    PivotCacheItemList  maSharedItems;      
    PivotCacheItemList  maGroupItems;       
    IndexVector         maDiscreteItems;    
    PCFieldModel        maFieldModel;       
    PCSharedItemsModel  maSharedItemsModel; 
    PCFieldGroupModel   maFieldGroupModel;  
};

struct PCDefinitionModel
{
    OUString     maRelId;            
    OUString     maRefreshedBy;      
    double              mfRefreshedDate;    
    sal_Int32           mnRecords;          
    sal_Int32           mnMissItemsLimit;   
    bool                mbInvalid;          
    bool                mbSaveData;         
    bool                mbRefreshOnLoad;    
    bool                mbOptimizeMemory;   
    bool                mbEnableRefresh;    
    bool                mbBackgroundQuery;  
    bool                mbUpgradeOnRefresh; 
    bool                mbTupleCache;       
    bool                mbSupportSubquery;  
    bool                mbSupportDrill;     

    explicit            PCDefinitionModel();
};

struct PCSourceModel
{
    sal_Int32           mnSourceType;       
    sal_Int32           mnConnectionId;     

    explicit            PCSourceModel();
};

struct PCWorksheetSourceModel
{
    OUString     maRelId;            
    OUString     maSheet;            
    OUString     maDefName;          
    ScRange      maRange;            

    explicit            PCWorksheetSourceModel();
};

class PivotCache : public WorkbookHelper
{
public:
    explicit            PivotCache( const WorkbookHelper& rHelper );

    void                importPivotCacheDefinition( const AttributeList& rAttribs );
    void                importCacheSource( const AttributeList& rAttribs );
    void                importWorksheetSource( const AttributeList& rAttribs, const ::oox::core::Relations& rRelations );

    void                importPCDefinition( SequenceInputStream& rStrm );
    void                importPCDSource( SequenceInputStream& rStrm );
    void                importPCDSheetSource( SequenceInputStream& rStrm, const ::oox::core::Relations& rRelations );

    PivotCacheField&    createCacheField();
    void                finalizeImport();

    bool         isValidDataSource() const { return mbValidSource; }
    bool         isBasedOnDummySheet() const { return mbDummySheet; }
    const ScRange&
                        getSourceRange() const { return maSheetSrcModel.maRange; }
    const OUString& getRecordsRelId() const { return maDefModel.maRelId; }

    PivotCacheField* getCacheField( sal_Int32 nFieldIdx );
    const PivotCacheField* getCacheField( sal_Int32 nFieldIdx ) const;
    sal_Int32           getCacheDatabaseIndex( sal_Int32 nFieldIdx ) const;

    void                writeSourceHeaderCells( const WorksheetHelper& rSheetHelper ) const;
    void                writeSourceDataCell( const WorksheetHelper& rSheetHelper,
                            sal_Int32 nColIdx, sal_Int32 nRowIdx,
                            const PivotCacheItem& rItem ) const;

    void                importPCRecord( SequenceInputStream& rStrm,
                            const WorksheetHelper& rSheetHelper, sal_Int32 nRowIdx ) const;

private:

    void                finalizeInternalSheetSource();
    void                finalizeExternalSheetSource();
    void                prepareSourceDataSheet();
    void                updateSourceDataRow( const WorksheetHelper& rSheetHelper, sal_Int32 nRow ) const;

private:
    typedef RefVector< PivotCacheField >    PivotCacheFieldVector;
    typedef ::std::vector< sal_Int32 >      IndexVector;

    PivotCacheFieldVector maFields;         
    PivotCacheFieldVector maDatabaseFields; 
    IndexVector         maDatabaseIndexes;  
    PCDefinitionModel   maDefModel;         
    PCSourceModel       maSourceModel;      
    PCWorksheetSourceModel maSheetSrcModel; 
    ValueRangeSet       maColSpans;         
    OUString     maTargetUrl;        
    mutable sal_Int32   mnCurrRow;          
    bool                mbValidSource;      
    bool                mbDummySheet;       
};

class PivotCacheBuffer : public WorkbookHelper
{
public:
    explicit            PivotCacheBuffer( const WorkbookHelper& rHelper );

    void                registerPivotCacheFragment( sal_Int32 nCacheId, const OUString& rFragmentPath );

    PivotCache*         importPivotCacheFragment( sal_Int32 nCacheId );

private:
    PivotCache&         createPivotCache( sal_Int32 nCacheId );

private:
    typedef ::std::map< sal_Int32, OUString >    FragmentPathMap;
    typedef RefMap< sal_Int32, PivotCache >             PivotCacheMap;

    FragmentPathMap           maFragmentPaths;
    PivotCacheMap             maCaches;
    std::vector< sal_Int32 >  maCacheIds;
};

} // namespace oox::xls

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */