xipivot.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 "xlpivot.hxx"
#include "xiroot.hxx"
#include <vector>
#include <memory>
 
class ScDPSaveData;
class ScDPSaveDimension;
 
// Pivot cache
 
class XclImpPCItem : public XclPCItem
{
public:
    explicit            XclImpPCItem( XclImpStream& rStrm );
 
    void WriteToSource( XclImpRoot& rRoot, const ScAddress& rScPos ) const;
 
private:
    void                ReadSxdouble( XclImpStream& rStrm );
    void                ReadSxboolean( XclImpStream& rStrm );
    void                ReadSxerror( XclImpStream& rStrm );
    void                ReadSxinteger( XclImpStream& rStrm );
    void                ReadSxstring( XclImpStream& rStrm );
    void                ReadSxdatetime( XclImpStream& rStrm );
    void                ReadSxempty( XclImpStream& rStrm );
};
 
typedef std::shared_ptr< XclImpPCItem > XclImpPCItemRef;
 
struct ScDPNumGroupInfo;
class XclImpPivotCache;
 
class XclImpPCField : public XclPCField, protected XclImpRoot
{
public:
    explicit            XclImpPCField( const XclImpRoot& rRoot,
                            XclImpPivotCache& rPCache, sal_uInt16 nFieldIdx );
    virtual             ~XclImpPCField() override;
 
    // general field/item access ----------------------------------------------
 
    const OUString& GetFieldName( const ScfStringVec& rVisNames ) const;
 
    const XclImpPCField* GetGroupBaseField() const;
 
    const XclImpPCItem* GetItem( sal_uInt16 nItemIdx ) const;
    const XclImpPCItem* GetLimitItem( sal_uInt16 nItemIdx ) const;
 
    void WriteFieldNameToSource( SCCOL nScCol, SCTAB nScTab );
    void WriteOrigItemToSource( SCROW nScRow, SCTAB nScTab, sal_uInt16 nItemIdx );
    void WriteLastOrigItemToSource( SCROW nScRow, SCTAB nScTab );
 
    // records ----------------------------------------------------------------
 
    void                ReadSxfield( XclImpStream& rStrm );
    void                ReadItem( XclImpStream& rStrm );
    void                ReadSxnumgroup( XclImpStream& rStrm );
    void                ReadSxgroupinfo( XclImpStream& rStrm );
 
    // grouping ---------------------------------------------------------------
 
    void                ConvertGroupField( ScDPSaveData& rSaveData, const ScfStringVec& rVisNames ) const;
 
private:
    void                ConvertStdGroupField( ScDPSaveData& rSaveData, const ScfStringVec& rVisNames ) const;
    void                ConvertNumGroupField( ScDPSaveData& rSaveData, const ScfStringVec& rVisNames ) const;
    void                ConvertDateGroupField( ScDPSaveData& rSaveData, const ScfStringVec& rVisNames ) const;
 
    ScDPNumGroupInfo    GetScNumGroupInfo() const;
    ScDPNumGroupInfo    GetScDateGroupInfo() const;
 
    const double*       GetNumGroupLimit( sal_uInt16 nLimitIdx ) const;
    const DateTime*     GetDateGroupLimit( sal_uInt16 nLimitIdx ) const;
    const sal_Int16*    GetDateGroupStep() const;
 
private:
    typedef ::std::vector< XclImpPCItemRef > XclImpPCItemVec;
 
    XclImpPivotCache&   mrPCache;           
    XclImpPCItemVec     maItems;            
    XclImpPCItemVec     maOrigItems;        
    XclImpPCItemVec     maNumGroupItems;    
    mutable SCCOL       mnSourceScCol;      
    bool                mbNumGroupInfoRead; 
};
 
typedef std::shared_ptr< XclImpPCField > XclImpPCFieldRef;
 
class XclImpPivotCache : protected XclImpRoot
{
public:
    explicit            XclImpPivotCache( const XclImpRoot& rRoot );
    virtual             ~XclImpPivotCache() override;
 
    // data access ------------------------------------------------------------
 
    const ScRange& GetSourceRange() const { return maSrcRange; }
 
    const OUString& GetSourceRangeName() const { return maSrcRangeName; }
 
    const XclImpPCField* GetField( sal_uInt16 nFieldIdx ) const;
 
    // records ----------------------------------------------------------------
 
    void                ReadSxidstm( XclImpStream& rStrm );
    void                ReadSxvs( XclImpStream& rStrm );
    void                ReadDconref( XclImpStream& rStrm );
    void                ReadDConName( XclImpStream& rStrm );
    void                ReadPivotCacheStream( const XclImpStream& rStrm );
 
    bool                IsRefreshOnLoad() const;
    bool                IsValid() const;
 
private:
    typedef ::std::vector< XclImpPCFieldRef > XclImpPCFieldVec;
 
    XclPCInfo           maPCInfo;           
    XclImpPCFieldVec    maFields;           
    ScRange             maSrcRange;         
    OUString            maUrl;              
    OUString            maTabName;          
    OUString            maSrcRangeName;     
    sal_uInt16          mnStrmId;           
    sal_uInt16          mnSrcType;          
    bool                mbSelfRef;          
};
 
typedef std::shared_ptr< XclImpPivotCache > XclImpPivotCacheRef;
 
// Pivot table
 
class XclImpPivotTable;
 
class XclImpPTItem
{
public:
    explicit            XclImpPTItem( const XclImpPCField* pCacheField );
 
    const OUString* GetItemName() const;
    std::pair<bool, OUString> GetItemName(const ScDPSaveDimension& rSaveDim, ScDPObject* pObj, const XclImpRoot& rRoot) const;
 
    void                ReadSxvi( XclImpStream& rStrm );
 
    void                ConvertItem( ScDPSaveDimension& rSaveDim, ScDPObject* pObj, const XclImpRoot& rRoot ) const;
 
private:
    XclPTItemInfo       maItemInfo;         
    const XclImpPCField* mpCacheField;      
};
 
typedef std::shared_ptr< XclImpPTItem > XclImpPTItemRef;
 
class XclImpPTField
{
public:
    explicit            XclImpPTField( const XclImpPivotTable& rPTable, sal_uInt16 nCacheIdx );
 
    // general field/item access ----------------------------------------------
 
    const XclImpPCField* GetCacheField() const;
    OUString        GetFieldName() const;
    OUString        GetVisFieldName() const;
 
    const XclImpPTItem* GetItem( sal_uInt16 nItemIdx ) const;
    const OUString* GetItemName( sal_uInt16 nItemIdx ) const;
 
    sal_uInt16   GetAxes() const { return maFieldInfo.mnAxes; }
    void         SetAxes( sal_uInt16 nAxes ) { maFieldInfo.mnAxes = nAxes; }
 
    // records ----------------------------------------------------------------
 
    void                ReadSxvd( XclImpStream& rStrm );
    void                ReadSxvdex( XclImpStream& rStrm );
    void                ReadSxvi( XclImpStream& rStrm );
 
    // row/column fields ------------------------------------------------------
 
    void                ConvertRowColField( ScDPSaveData& rSaveData ) const;
 
    // page fields ------------------------------------------------------------
 
    void                SetPageFieldInfo( const XclPTPageFieldInfo& rPageInfo );
    void                ConvertPageField( ScDPSaveData& rSaveData ) const;
 
    // hidden fields ----------------------------------------------------------
 
    void                ConvertHiddenField( ScDPSaveData& rSaveData ) const;
 
    // data fields ------------------------------------------------------------
 
    bool                HasDataFieldInfo() const;
    void                AddDataFieldInfo( const XclPTDataFieldInfo& rDataInfo );
    void                ConvertDataField( ScDPSaveData& rSaveData ) const;
 
    void                ConvertFieldInfo( const ScDPSaveData& rSaveData, ScDPObject* pObj, const XclImpRoot& rRoot, bool bPageField = false ) const;
 
private:
    void                ConvertRCPField( ScDPSaveData& rSaveData ) const;
 
    void                ConvertDataField( ScDPSaveDimension& rSaveDim, const XclPTDataFieldInfo& rDataInfo ) const;
    void                ConvertDataFieldInfo( ScDPSaveDimension& rSaveDim, const XclPTDataFieldInfo& rDataInfo ) const;
 
private:
 
    const XclImpPivotTable& mrPTable;       
    XclPTFieldInfo      maFieldInfo;        
    XclPTFieldExtInfo   maFieldExtInfo;     
    XclPTPageFieldInfo  maPageInfo;         
    std::vector< XclPTDataFieldInfo > maDataInfoVector;  
    std::vector< XclImpPTItemRef >    maItems;           
};
 
typedef std::shared_ptr< XclImpPTField > XclImpPTFieldRef;
 
class XclImpPivotTable : protected XclImpRoot
{
public:
    explicit            XclImpPivotTable( const XclImpRoot& rRoot );
    virtual             ~XclImpPivotTable() override;
 
    // cache/field access, misc. ----------------------------------------------
 
    const XclImpPivotCacheRef& GetPivotCache() const { return mxPCache; }
    const ScfStringVec& GetVisFieldNames() const { return maVisFieldNames; }
 
    sal_uInt16          GetFieldCount() const;
    const XclImpPTField* GetField( sal_uInt16 nFieldIdx ) const;
    XclImpPTField*      GetFieldAcc( sal_uInt16 nFieldIdx );
 
    const XclImpPTField* GetDataField( sal_uInt16 nDataFieldIdx ) const;
    OUString GetDataFieldName( sal_uInt16 nDataFieldIdx ) const;
 
    // records ----------------------------------------------------------------
 
    void                ReadSxview( XclImpStream& rStrm );
    void                ReadSxvd( XclImpStream& rStrm );
    void                ReadSxvi( XclImpStream& rStrm );
    void                ReadSxvdex( XclImpStream& rStrm );
    void                ReadSxivd( XclImpStream& rStrm );
    void                ReadSxpi( XclImpStream& rStrm );
    void                ReadSxdi( XclImpStream& rStrm );
    void                ReadSxex( XclImpStream& rStrm );
    void                ReadSxViewEx9( XclImpStream& rStrm );
 
    void                ReadSxAddl( XclImpStream& rStrm );
 
    void                Convert();
 
    void                MaybeRefresh();
 
    void                ApplyMergeFlags(const ScRange& rOutRange, const ScDPSaveData& rSaveData);
    void                ApplyFieldInfo();
 
private:
    XclImpPivotCacheRef mxPCache;           
 
    XclPTInfo           maPTInfo;           
    XclPTExtInfo        maPTExtInfo;        
    XclPTViewEx9Info    maPTViewEx9Info;     
    XclPTAddl           maPTAddlInfo;
    std::vector< XclImpPTFieldRef >
                        maFields;           
    XclImpPTFieldRef    mxCurrField;        
    ScfStringVec        maVisFieldNames;    
    ScfUInt16Vec        maRowFields;        
    ScfUInt16Vec        maColFields;        
    ScfUInt16Vec        maPageFields;       
    ScfUInt16Vec        maOrigDataFields;   
    ScfUInt16Vec        maFiltDataFields;   
    XclImpPTField       maDataOrientField;  
    ScRange             maOutScRange;       
    ScDPObject*         mpDPObj;
};
 
typedef std::shared_ptr< XclImpPivotTable > XclImpPivotTableRef;
 
class XclImpPivotTableManager : protected XclImpRoot
{
public:
    explicit            XclImpPivotTableManager( const XclImpRoot& rRoot );
    virtual             ~XclImpPivotTableManager() override;
 
    // pivot cache records ----------------------------------------------------
 
    XclImpPivotCacheRef GetPivotCache( sal_uInt16 nCacheIdx );
 
    void                ReadSxidstm( XclImpStream& rStrm );
    void                ReadSxvs( XclImpStream& rStrm );
    void                ReadDconref( XclImpStream& rStrm );
    void                ReadDConName( XclImpStream& rStrm );
 
    // pivot table records ----------------------------------------------------
 
    void                ReadSxview( XclImpStream& rStrm );
    void                ReadSxvd( XclImpStream& rStrm );
    void                ReadSxvdex( XclImpStream& rStrm );
    void                ReadSxivd( XclImpStream& rStrm );
    void                ReadSxpi( XclImpStream& rStrm );
    void                ReadSxdi( XclImpStream& rStrm );
    void                ReadSxvi( XclImpStream& rStrm );
    void                ReadSxex( XclImpStream& rStrm );
    void                ReadSxViewEx9( XclImpStream& rStrm );
    void                ReadSxAddl( XclImpStream& rStrm );
 
    void                ReadPivotCaches( const XclImpStream& rStrm );
    void                ConvertPivotTables();
 
    void                MaybeRefreshPivotTables();
 
private:
 
    std::vector< XclImpPivotCacheRef >  maPCaches; 
    std::vector< XclImpPivotTableRef >  maPTables; 
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */