sc/inc/dpfilteredcache.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef SC_DPCACHETABLE_HXX
  21 #define SC_DPCACHETABLE_HXX
  22
  23 #include "sal/types.h"
  24 #include "osl/mutex.hxx"
  25 #include "global.hxx"
  26 #include "dpitemdata.hxx"
  27 #include "dpmacros.hxx"
  28
  29 #include <vector>
  30 #include <boost/unordered_set.hpp>
  31 #include <boost/shared_ptr.hpp>
  32
  33 #include <mdds/flat_segment_tree.hpp>
  34
  35 class ScDPItemData;
  36 class ScDPCache;
  37 class ScDocument;
  38 class ScRange;
  39 struct ScDPValue;
  40 struct ScQueryParam;
  41
  42 /**
  43  * This class is only a wrapper to the actual cache, to provide filtering on
  44  * the raw data based on the query filter and/or page field filters.
  45  */
  46 class SC_DLLPUBLIC ScDPFilteredCache
  47 {
  48     typedef mdds::flat_segment_tree<SCROW, bool> RowFlagType;
  49
  50 public:
  51     /** interface class used for filtering of rows. */
  52     class FilterBase
  53     {
  54     public:
  55         virtual ~FilterBase() {}
  56         /** returns true if the matching condition is met for a single cell
  57             value, or false otherwise. */
  58         virtual bool match( const  ScDPItemData& rCellData ) const = 0;
  59
  60         virtual std::vector<ScDPItemData> getMatchValues() const = 0;
  61     };
  62
  63     /** ordinary single-item filter. */
  64     class SingleFilter : public FilterBase
  65     {
  66     public:
  67         explicit SingleFilter(const ScDPItemData &rItem);
  68         virtual ~SingleFilter() {}
  69
  70         virtual bool match(const ScDPItemData& rCellData) const;
  71         virtual std::vector<ScDPItemData> getMatchValues() const;
  72         const ScDPItemData& getMatchValue() const;
  73
  74     private:
  75         explicit SingleFilter();
  76
  77         ScDPItemData maItem;
  78     };
  79
  80     /** multi-item (group) filter. */
  81     class GroupFilter : public FilterBase
  82     {
  83     public:
  84         GroupFilter();
  85         virtual ~GroupFilter() {}
  86         virtual bool match(const ScDPItemData& rCellData) const;
  87         virtual std::vector<ScDPItemData> getMatchValues() const;
  88         void addMatchItem(const ScDPItemData& rItem);
  89         size_t getMatchItemCount() const;
  90
  91     private:
  92         ::std::vector<ScDPItemData> maItems;
  93     };
  94
  95     /** single filtering criterion. */
  96     struct Criterion
  97     {
  98         sal_Int32 mnFieldIndex;
  99         ::boost::shared_ptr<FilterBase> mpFilter;
 100
 101         Criterion();
 102     };
 103
 104     ScDPFilteredCache(const ScDPCache& rCache);
 105     ~ScDPFilteredCache();
 106
 107     sal_Int32 getRowSize() const;
 108     sal_Int32 getColSize() const;
 109
 110     const ScDPCache* getCache() const;
 111
 112     void fillTable(const ScQueryParam& rQuery, bool bIgnoreEmptyRows, bool bRepeatIfEmpty);
 113
 114     void fillTable();
 115
 116     /** Check whether a specified row is active or not.  When a row is active,
 117         it is used in calculation of the results data.  A row becomes inactive
 118         when it is filtered out by page field. */
 119     bool isRowActive(sal_Int32 nRow, sal_Int32* pLastRow = NULL) const;
 120
 121     /** Set filter on/off flag to each row to control visibility.  The caller
 122         must ensure that the table is filled before calling this function. */
 123     void filterByPageDimension(const ::std::vector<Criterion>& rCriteria, const ::boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims);
 124
 125     /** Get the cell instance at specified location within the data grid. Note
 126         that the data grid doesn't include the header row.  Don't delete the
 127         returned object! */
 128     const ScDPItemData* getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const;
 129     void  getValue( ScDPValue& rVal, SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const;
 130     OUString getFieldName(SCCOL nIndex) const;
 131
 132    /** Get the unique entries for a field specified by index.  The caller must
 133        make sure that the table is filled before calling function, or it will
 134        get an empty collection. */
 135     const ::std::vector<SCROW>& getFieldEntries( sal_Int32 nColumn ) const;
 136
 137     /** Filter the table based on the specified criteria, and copy the
 138         result to rTabData.  This method is used, for example, to generate
 139         a drill-down data table. */
 140     void filterTable(const ::std::vector<Criterion>& rCriteria,
 141                      ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rTabData,
 142                      const ::boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims);
 143
 144     SCROW getOrder(long nDim, SCROW nIndex) const;
 145     void clear();
 146     bool empty() const;
 147
 148 #if DEBUG_PIVOT_TABLE
 149     void dumpRowFlag(const RowFlagType& rFlag) const;
 150     void dump() const;
 151 #endif
 152
 153 private:
 154     ScDPFilteredCache();
 155     ScDPFilteredCache(const ScDPFilteredCache&);
 156
 157     /**
 158      * Check if a given row meets all specified criteria.
 159      *
 160      * @param nRow index of row to be tested.
 161      * @param rCriteria a list of criteria
 162      */
 163     bool isRowQualified(sal_Int32 nRow, const ::std::vector<Criterion>& rCriteria, const ::boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims) const;
 164
 165 private:
 166
 167     /** unique field entires for each field (column). */
 168     ::std::vector< ::std::vector<SCROW> > maFieldEntries;
 169
 170     /** Rows visible by standard filter query. */
 171     RowFlagType maShowByFilter;
 172     /** Rows visible by page dimension filtering. */
 173     RowFlagType maShowByPage;
 174
 175     const ScDPCache& mrCache;
 176 };
 177 #endif
 178
 179 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */