xepivot.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 "xerecord.hxx"
#include "xlpivot.hxx"
#include "xeroot.hxx"
 
class ScDPObject;
class ScDPSaveData;
class ScDPSaveDimension;
class ScDPSaveMember;
class ScDPSaveGroupDimension;
struct ScDPNumGroupInfo;
 
// Pivot cache
 
class XclExpPCItem : public XclExpRecord, public XclPCItem
{
public:
    explicit            XclExpPCItem( const OUString& rText );
    explicit            XclExpPCItem( double fValue, const OUString& rText = OUString() );
    explicit            XclExpPCItem( const DateTime& rDateTime, const OUString& rText = OUString() );
    explicit            XclExpPCItem( sal_Int16 nValue );
    explicit            XclExpPCItem( bool bValue, const OUString& rText );
 
    sal_uInt16   GetTypeFlag() const { return mnTypeFlag; }
 
    bool                EqualsText( std::u16string_view rText ) const;
    bool                EqualsDouble( double fValue ) const;
    bool                EqualsDateTime( const DateTime& rDateTime ) const;
    bool                EqualsBool( bool bValue ) const;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    sal_uInt16          mnTypeFlag;         
};
 
class XclExpPCField : public XclExpRecord, public XclPCField, protected XclExpRoot
{
public:
    explicit            XclExpPCField( const XclExpRoot& rRoot,
                            sal_uInt16 nFieldIdx,
                            const ScDPObject& rDPObj, const ScRange& rRange );
    explicit            XclExpPCField( const XclExpRoot& rRoot,
                            sal_uInt16 nFieldIdx,
                            const ScDPObject& rDPObj, const ScDPSaveGroupDimension& rGroupDim,
                            const XclExpPCField& rBaseField );
    virtual             ~XclExpPCField() override;
 
    void                SetGroupChildField( const XclExpPCField& rChildField );
 
    const OUString& GetFieldName() const { return maFieldInfo.maName; }
 
    sal_uInt16          GetItemCount() const;
    const XclExpPCItem* GetItem( sal_uInt16 nItemIdx ) const;
    sal_uInt16          GetItemIndex( std::u16string_view rItemName ) const;
 
    std::size_t         GetIndexSize() const;
    void                WriteIndex( XclExpStream& rStrm, sal_uInt32 nSrcRow ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    typedef XclExpRecordList< XclExpPCItem >    XclExpPCItemList;
 
    const XclExpPCItemList& GetVisItemList() const;
 
    void                InitStandardField( const ScRange& rRange );
    void                InitStdGroupField( const XclExpPCField& rBaseField, const ScDPSaveGroupDimension& rGroupDim );
    void                InitNumGroupField( const ScDPObject& rDPObj, const ScDPNumGroupInfo& rNumInfo );
    void                InitDateGroupField( const ScDPObject& rDPObj, const ScDPNumGroupInfo& rDateInfo, sal_Int32 nDatePart );
 
    void                InsertItemArrayIndex( size_t nListPos );
    void                InsertOrigItem( XclExpPCItem* pNewItem );
    void                InsertOrigTextItem( const OUString& rText );
    void                InsertOrigDoubleItem( double fValue, const OUString& rText );
    void                InsertOrigDateTimeItem( const DateTime& rDateTime, const OUString& rText );
    void                InsertOrigBoolItem( bool bValue, const OUString& rText );
 
    sal_uInt16          InsertGroupItem( XclExpPCItem* pNewItem );
    void                InsertNumDateGroupItems( const ScDPObject& rDPObj, const ScDPNumGroupInfo& rNumInfo, sal_Int32 nDatePart = 0 );
 
    void                SetNumGroupLimit( const ScDPNumGroupInfo& rNumInfo );
    void                SetDateGroupLimit( const ScDPNumGroupInfo& rDateInfo, bool bUseStep );
 
    void                Finalize();
 
    void                WriteSxnumgroup( XclExpStream& rStrm );
    void                WriteSxgroupinfo( XclExpStream& rStrm );
 
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    XclExpPCItemList    maOrigItemList;     
    XclExpPCItemList    maGroupItemList;    
    ScfUInt16Vec        maIndexVec;         
    XclExpPCItemList    maNumGroupLimits;   
    sal_uInt16          mnTypeFlags;        
};
 
class XclExpPivotCache : public salhelper::SimpleReferenceObject, protected XclExpRoot
{
public:
    explicit            XclExpPivotCache( const XclExpRoot& rRoot,
                            const ScDPObject& rDPObj, sal_uInt16 nListIdx );
 
    bool         IsValid() const { return mbValid; }
    bool                HasItemIndexList() const;
 
    sal_uInt16   GetCacheIndex() const { return mnListIdx; }
 
    sal_uInt16          GetFieldCount() const;
    const XclExpPCField* GetField( sal_uInt16 nFieldIdx ) const;
    bool                HasAddFields() const;
 
    bool                HasEqualDataSource( const ScDPObject& rDPObj ) const;
 
    void        Save( XclExpStream& rStrm );
    static void SaveXml( XclExpXmlStream& rStrm );
 
private:
    void                AddFields( const ScDPObject& rDPObj );
 
    void                AddStdFields( const ScDPObject& rDPObj );
    void                AddGroupFields( const ScDPObject& rDPObj );
 
    void                WriteDconref( XclExpStream& rStrm ) const;
    void                WriteDConName( XclExpStream& rStrm ) const;
 
    void                WriteCacheStream();
    void                WriteSxdb( XclExpStream& rStrm ) const;
    static void         WriteSxdbex( XclExpStream& rStrm );
    void                WriteSxindexlistList( XclExpStream& rStrm ) const;
 
private:
    typedef XclExpRecordList< XclExpPCField >   XclExpPCFieldList;
    typedef XclExpPCFieldList::RecordRefType    XclExpPCFieldRef;
 
    XclPCInfo           maPCInfo;           
    XclExpPCFieldList   maFieldList;        
    OUString       maTabName;          
    OUString       maSrcRangeName;     
    ScRange             maOrigSrcRange;     
    ScRange             maExpSrcRange;      
    ScRange             maDocSrcRange;      
    sal_uInt16          mnListIdx;          
    bool                mbValid;            
};
 
typedef rtl::Reference<XclExpPivotCache>       XclExpPivotCacheRef;
 
// Pivot table
 
class XclExpPivotTable;
 
typedef ::std::pair< sal_uInt16, sal_uInt16 > XclPTDataFieldPos;
 
class XclExpPTItem : public XclExpRecord
{
public:
    explicit            XclExpPTItem( const XclExpPCField& rCacheField, sal_uInt16 nCacheIdx );
    explicit            XclExpPTItem( sal_uInt16 nItemType, sal_uInt16 nCacheIdx );
 
    OUString       GetItemName() const;
 
    void                SetPropertiesFromMember( const ScDPSaveMember& rSaveMem );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    const XclExpPCItem* mpCacheItem;        
    XclPTItemInfo       maItemInfo;         
};
 
class XclExpPTField : public XclExpRecordBase
{
public:
    explicit            XclExpPTField( const XclExpPivotTable& rPTable, sal_uInt16 nCacheIdx );
 
    // data access ------------------------------------------------------------
 
    OUString       GetFieldName() const;
    sal_uInt16          GetFieldIndex() const { return maFieldInfo.mnCacheIdx; }
 
    sal_uInt16          GetLastDataInfoIndex() const;
 
    sal_uInt16          GetItemIndex( std::u16string_view rName, sal_uInt16 nDefaultIdx ) const;
 
    // fill data --------------------------------------------------------------
 
    void                SetPropertiesFromDim( const ScDPSaveDimension& rSaveDim );
    void                SetDataPropertiesFromDim( const ScDPSaveDimension& rSaveDim );
 
    void                AppendSubtotalItems();
 
    // records ----------------------------------------------------------------
 
    void                WriteSxpiEntry( XclExpStream& rStrm ) const;
    void                WriteSxdi( XclExpStream& rStrm, sal_uInt16 nDataInfoIdx ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    XclExpPTItem*       GetItemAcc( std::u16string_view rName );
 
    void                AppendSubtotalItem( sal_uInt16 nItemType );
 
    void                WriteSxvd( XclExpStream& rStrm ) const;
    void                WriteSxvdex( XclExpStream& rStrm ) const;
 
private:
 
    const XclExpPivotTable& mrPTable;       
    const XclExpPCField* mpCacheField;      
    XclPTFieldInfo      maFieldInfo;        
    XclPTFieldExtInfo   maFieldExtInfo;     
    XclPTPageFieldInfo  maPageInfo;         
    std::vector< XclPTDataFieldInfo >
                        maDataInfoVec;    
    XclExpRecordList< XclExpPTItem >
                        maItemList;         
};
 
class XclExpPivotTable : public XclExpRecordBase, protected XclExpRoot
{
public:
    explicit            XclExpPivotTable( const XclExpRoot& rRoot,
                            const ScDPObject& rDPObj, const XclExpPivotCache& rPCache );
 
    const XclExpPCField* GetCacheField( sal_uInt16 nCacheIdx ) const;
 
    SCTAB         GetScTab() const { return mnOutScTab; }
 
    const XclExpPTField* GetField( sal_uInt16 nFieldIdx ) const;
    const XclExpPTField* GetField( std::u16string_view rName ) const;
 
    sal_uInt16          GetDataFieldIndex( const OUString& rName, sal_uInt16 nDefaultIdx ) const;
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    XclExpPTField*      GetFieldAcc( std::u16string_view rName );
    XclExpPTField*      GetFieldAcc( const ScDPSaveDimension& rSaveDim );
 
    // fill data --------------------------------------------------------------
 
    void                SetPropertiesFromDP( const ScDPSaveData& rSaveData );
    void                SetFieldPropertiesFromDim( const ScDPSaveDimension& rSaveDim );
    void                SetDataFieldPropertiesFromDim( const ScDPSaveDimension& rSaveDim );
 
    void                Finalize();
 
    // records ----------------------------------------------------------------
 
    void                WriteSxview( XclExpStream& rStrm ) const;
    static void         WriteSxivd( XclExpStream& rStrm, const ScfUInt16Vec& rFields );
    void                WriteSxpi( XclExpStream& rStrm ) const;
    void                WriteSxdiList( XclExpStream& rStrm ) const;
    static void         WriteSxli( XclExpStream& rStrm, sal_uInt16 nLineCount, sal_uInt16 nIndexCount );
    void                WriteSxex( XclExpStream& rStrm ) const;
 
    void                WriteQsiSxTag( XclExpStream& rStrm ) const;
    void                WriteSxViewEx9( XclExpStream& rStrm ) const;
 
private:
    typedef XclExpRecordList< XclExpPTField >   XclExpPTFieldList;
    typedef XclExpPTFieldList::RecordRefType    XclExpPTFieldRef;
 
    const XclExpPivotCache& mrPCache;       
    XclPTInfo           maPTInfo;           
    XclPTExtInfo        maPTExtInfo;        
    XclPTViewEx9Info    maPTViewEx9Info;    
    XclExpPTFieldList   maFieldList;        
    ScfUInt16Vec        maRowFields;        
    ScfUInt16Vec        maColFields;        
    ScfUInt16Vec        maPageFields;       
    std::vector< XclPTDataFieldPos >
                        maDataFields;      
    XclExpPTField       maDataOrientField;  
    SCTAB               mnOutScTab;         
    bool                mbValid;            
    bool                mbFilterBtn;        
};
 
class XclExpPivotTableManager : protected XclExpRoot
{
public:
    explicit            XclExpPivotTableManager( const XclExpRoot& rRoot );
 
    void                CreatePivotTables();
 
    XclExpRecordRef     CreatePivotCachesRecord();
    XclExpRecordRef     CreatePivotTablesRecord( SCTAB nScTab );
 
    void                WritePivotCaches( XclExpStream& rStrm );
    void                WritePivotTables( XclExpStream& rStrm, SCTAB nScTab );
 
private:
    const XclExpPivotCache* CreatePivotCache( const ScDPObject& rDPObj );
 
private:
    typedef XclExpRecordList< XclExpPivotTable >    XclExpPivotTableList;
    typedef XclExpPivotTableList::RecordRefType     XclExpPivotTableRef;
 
    XclExpRecordList< XclExpPivotCache > maPCacheList;      
    XclExpPivotTableList                 maPTableList;      
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */