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: */