Rename ScDPCacheTable to ScDPFilteredCache.

I always wanted to do this.  The new name reflects what it really does
better than the old one.

Change-Id: I3c90cce06d482f1453936ff3916eef9663bb417b

7 files changed, 81 insertions, 80 deletions

diff --git a/sc/source/core/data/dpcachetable.cxx b/sc/source/core/data/dpcachetable.cxx
index 6a648a9cd9b8..1da99f64a33d 100644
--- a/sc/source/core/data/dpcachetable.cxx
+++ b/sc/source/core/data/dpcachetable.cxx
@@ -64,24 +64,24 @@ using ::com::sun::star::uno::UNO_QUERY;
 using ::com::sun::star::uno::UNO_QUERY_THROW;
 using ::com::sun::star::sheet::DataPilotFieldFilter;
 
-ScDPCacheTable::SingleFilter::SingleFilter(const ScDPItemData& rItem) :
+ScDPFilteredCache::SingleFilter::SingleFilter(const ScDPItemData& rItem) :
     maItem(rItem) {}
 
-bool ScDPCacheTable::SingleFilter::match(const ScDPItemData& rCellData) const
+bool ScDPFilteredCache::SingleFilter::match(const ScDPItemData& rCellData) const
 {
     return maItem == rCellData;
 }
 
-const ScDPItemData& ScDPCacheTable::SingleFilter::getMatchValue() const
+const ScDPItemData& ScDPFilteredCache::SingleFilter::getMatchValue() const
 {
     return maItem;
 }
 
-ScDPCacheTable::GroupFilter::GroupFilter()
+ScDPFilteredCache::GroupFilter::GroupFilter()
 {
 }
 
-bool ScDPCacheTable::GroupFilter::match(const ScDPItemData& rCellData) const
+bool ScDPFilteredCache::GroupFilter::match(const ScDPItemData& rCellData) const
 {
     vector<ScDPItemData>::const_iterator it = maItems.begin(), itEnd = maItems.end();
     for (; it != itEnd; ++it)
@@ -93,19 +93,19 @@ bool ScDPCacheTable::GroupFilter::match(const ScDPItemData& rCellData) const
     return false;
 }
 
-void ScDPCacheTable::GroupFilter::addMatchItem(const ScDPItemData& rItem)
+void ScDPFilteredCache::GroupFilter::addMatchItem(const ScDPItemData& rItem)
 {
     maItems.push_back(rItem);
 }
 
-size_t ScDPCacheTable::GroupFilter::getMatchItemCount() const
+size_t ScDPFilteredCache::GroupFilter::getMatchItemCount() const
 {
     return maItems.size();
 }
 
 // ----------------------------------------------------------------------------
 
-ScDPCacheTable::Criterion::Criterion() :
+ScDPFilteredCache::Criterion::Criterion() :
     mnFieldIndex(-1),
     mpFilter(static_cast<FilterBase*>(NULL))
 {
@@ -113,26 +113,26 @@ ScDPCacheTable::Criterion::Criterion() :
 
 // ----------------------------------------------------------------------------
 
-ScDPCacheTable::ScDPCacheTable(const ScDPCache& rCache) :
+ScDPFilteredCache::ScDPFilteredCache(const ScDPCache& rCache) :
     maShowByFilter(0, MAXROW+1, false), maShowByPage(0, MAXROW+1, true), mrCache(rCache)
 {
 }
 
-ScDPCacheTable::~ScDPCacheTable()
+ScDPFilteredCache::~ScDPFilteredCache()
 {
 }
 
-sal_Int32 ScDPCacheTable::getRowSize() const
+sal_Int32 ScDPFilteredCache::getRowSize() const
 {
     return mrCache.GetRowCount();
 }
 
-sal_Int32 ScDPCacheTable::getColSize() const
+sal_Int32 ScDPFilteredCache::getColSize() const
 {
     return mrCache.GetColumnCount();
 }
 
-void ScDPCacheTable::fillTable(
+void ScDPFilteredCache::fillTable(
     const ScQueryParam& rQuery, bool bIgnoreEmptyRows, bool bRepeatIfEmpty)
 {
     SCROW nRowCount = getRowSize();
@@ -208,7 +208,7 @@ void ScDPCacheTable::fillTable(
     }
 }
 
-void ScDPCacheTable::fillTable()
+void ScDPFilteredCache::fillTable()
 {
     SCROW nRowCount = getRowSize();
     SCCOL nColCount = getColSize();
@@ -250,7 +250,7 @@ void ScDPCacheTable::fillTable()
     }
 }
 
-bool ScDPCacheTable::isRowActive(sal_Int32 nRow, sal_Int32* pLastRow) const
+bool ScDPFilteredCache::isRowActive(sal_Int32 nRow, sal_Int32* pLastRow) const
 {
     bool bFilter = false, bPage = true;
     SCROW nLastRowFilter = MAXROW, nLastRowPage = MAXROW;
@@ -266,7 +266,7 @@ bool ScDPCacheTable::isRowActive(sal_Int32 nRow, sal_Int32* pLastRow) const
     return bFilter && bPage;
 }
 
-void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims)
+void ScDPFilteredCache::filterByPageDimension(const vector<Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims)
 {
     SCROW nRowSize = getRowSize();
 
@@ -280,13 +280,13 @@ void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, c
     maShowByPage.build_tree();
 }
 
-const ScDPItemData* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
+const ScDPItemData* ScDPFilteredCache::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
 {
    SCROW nId= mrCache.GetItemDataId(nCol, nRow, bRepeatIfEmpty);
    return mrCache.GetItemDataById( nCol, nId );
 }
 
-void  ScDPCacheTable::getValue( ScDPValueData& rVal, SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
+void  ScDPFilteredCache::getValue( ScDPValueData& rVal, SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
 {
     const ScDPItemData* pData = getCell( nCol, nRow, bRepeatIfEmpty );
 
@@ -299,12 +299,12 @@ void  ScDPCacheTable::getValue( ScDPValueData& rVal, SCCOL nCol, SCROW nRow, boo
         rVal.Set(0.0, SC_VALTYPE_EMPTY);
 }
 
-rtl::OUString ScDPCacheTable::getFieldName(SCCOL nIndex) const
+rtl::OUString ScDPFilteredCache::getFieldName(SCCOL nIndex) const
 {
     return mrCache.GetDimensionName(nIndex);
 }
 
-const ::std::vector<SCROW>&  ScDPCacheTable::getFieldEntries( sal_Int32 nColumn ) const
+const ::std::vector<SCROW>&  ScDPFilteredCache::getFieldEntries( sal_Int32 nColumn ) const
 {
     if (nColumn < 0 || static_cast<size_t>(nColumn) >= maFieldEntries.size())
     {
@@ -315,7 +315,7 @@ const ::std::vector<SCROW>&  ScDPCacheTable::getFieldEntries( sal_Int32 nColumn
     return maFieldEntries[nColumn];
 }
 
-void ScDPCacheTable::filterTable(const vector<Criterion>& rCriteria, Sequence< Sequence<Any> >& rTabData,
+void ScDPFilteredCache::filterTable(const vector<Criterion>& rCriteria, Sequence< Sequence<Any> >& rTabData,
                                  const boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims)
 {
     sal_Int32 nRowSize = getRowSize();
@@ -381,24 +381,24 @@ void ScDPCacheTable::filterTable(const vector<Criterion>& rCriteria, Sequence< S
         rTabData[i] = tableData[i];
 }
 
-SCROW ScDPCacheTable::getOrder(long nDim, SCROW nIndex) const
+SCROW ScDPFilteredCache::getOrder(long nDim, SCROW nIndex) const
 {
     return mrCache.GetOrder(nDim, nIndex);
 }
 
-void ScDPCacheTable::clear()
+void ScDPFilteredCache::clear()
 {
     maFieldEntries.clear();
     maShowByFilter.clear();
     maShowByPage.clear();
 }
 
-bool ScDPCacheTable::empty() const
+bool ScDPFilteredCache::empty() const
 {
     return maFieldEntries.empty();
 }
 
-bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria,
+bool ScDPFilteredCache::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria,
                                     const boost::unordered_set<sal_Int32>& rRepeatIfEmptyDims) const
 {
     sal_Int32 nColSize = getColSize();
@@ -419,7 +419,7 @@ bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCr
     return true;
 }
 
-const ScDPCache* ScDPCacheTable::getCache() const
+const ScDPCache* ScDPFilteredCache::getCache() const
 {
     return &mrCache;
 }
@@ -429,7 +429,7 @@ const ScDPCache* ScDPCacheTable::getCache() const
 using std::cout;
 using std::endl;
 
-void ScDPCacheTable::dumpRowFlag(const RowFlagType& rFlag) const
+void ScDPFilteredCache::dumpRowFlag(const RowFlagType& rFlag) const
 {
     RowFlagType::const_iterator it = rFlag.begin(), itEnd = rFlag.end();
     bool bShow = it->second;
@@ -443,7 +443,7 @@ void ScDPCacheTable::dumpRowFlag(const RowFlagType& rFlag) const
     }
 }
 
-void ScDPCacheTable::dump() const
+void ScDPFilteredCache::dump() const
 {
     cout << "--- pivot cache filter dump" << endl;
 
diff --git a/sc/source/core/data/dpgroup.cxx b/sc/source/core/data/dpgroup.cxx
index aba278556336..0eb4622c8b0c 100644
--- a/sc/source/core/data/dpgroup.cxx
+++ b/sc/source/core/data/dpgroup.cxx
@@ -63,7 +63,7 @@ using ::boost::shared_ptr;
 
 const sal_uInt16 SC_DP_LEAPYEAR = 1648;     // arbitrary leap year for date calculations
 
-class ScDPGroupNumFilter : public ScDPCacheTable::FilterBase
+class ScDPGroupNumFilter : public ScDPFilteredCache::FilterBase
 {
 public:
     ScDPGroupNumFilter(const ScDPItemData& rValue, const ScDPNumGroupInfo& rInfo);
@@ -103,7 +103,7 @@ bool ScDPGroupNumFilter::match(const ScDPItemData& rCellData) const
     return low <= rCellData.GetValue() && rCellData.GetValue() < high;
 }
 
-class ScDPGroupDateFilter : public ScDPCacheTable::FilterBase
+class ScDPGroupDateFilter : public ScDPFilteredCache::FilterBase
 {
 public:
     virtual ~ScDPGroupDateFilter() {}
@@ -309,7 +309,7 @@ bool ScDPGroupItem::HasCommonElement( const ScDPGroupItem& rOther ) const
     return false;
 }
 
-void ScDPGroupItem::FillGroupFilter( ScDPCacheTable::GroupFilter& rFilter ) const
+void ScDPGroupItem::FillGroupFilter( ScDPFilteredCache::GroupFilter& rFilter ) const
 {
     ScDPItemDataVec::const_iterator itrEnd = aElements.end();
     for (ScDPItemDataVec::const_iterator itr = aElements.begin(); itr != itrEnd; ++itr)
@@ -361,7 +361,7 @@ void ScDPGroupDimension::SetGroupDim( long nDim )
 }
 
 const std::vector<SCROW>& ScDPGroupDimension::GetColumnEntries(
-    const ScDPCacheTable& rCacheTable) const
+    const ScDPFilteredCache& rCacheTable) const
 {
     if (!maMemberEntries.empty())
         return maMemberEntries;
@@ -628,7 +628,7 @@ void ScDPGroupTableData::CreateCacheTable()
     pSourceData->CreateCacheTable();
 }
 
-void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>& rCriteria)
+void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPFilteredCache::Criterion>& rCriteria)
 {
     typedef boost::unordered_map<long, const ScDPGroupDimension*> GroupFieldMapType;
     GroupFieldMapType aGroupFieldIds;
@@ -638,17 +638,17 @@ void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>&
             aGroupFieldIds.insert( boost::unordered_map<long, const ScDPGroupDimension*>::value_type(itr->GetGroupDim(), &(*itr)) );
     }
 
-    vector<ScDPCacheTable::Criterion> aNewCriteria;
+    vector<ScDPFilteredCache::Criterion> aNewCriteria;
     aNewCriteria.reserve(rCriteria.size() + aGroups.size());
 
     // Go through all the filtered field names and process them appropriately.
 
     const ScDPCache* pCache = GetCacheTable().getCache();
-    vector<ScDPCacheTable::Criterion>::const_iterator itrEnd = rCriteria.end();
+    vector<ScDPFilteredCache::Criterion>::const_iterator itrEnd = rCriteria.end();
     GroupFieldMapType::const_iterator itrGrpEnd = aGroupFieldIds.end();
-    for (vector<ScDPCacheTable::Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
+    for (vector<ScDPFilteredCache::Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
     {
-        ScDPCacheTable::SingleFilter* pFilter = dynamic_cast<ScDPCacheTable::SingleFilter*>(itr->mpFilter.get());
+        ScDPFilteredCache::SingleFilter* pFilter = dynamic_cast<ScDPFilteredCache::SingleFilter*>(itr->mpFilter.get());
         if (!pFilter)
             // We expect this to be a single filter.
             continue;
@@ -659,7 +659,7 @@ void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>&
             if (IsNumGroupDimension(itr->mnFieldIndex))
             {
                 // internal number group field
-                ScDPCacheTable::Criterion aCri;
+                ScDPFilteredCache::Criterion aCri;
                 aCri.mnFieldIndex = itr->mnFieldIndex;
                 const ScDPNumGroupDimension& rNumGrpDim = pNumGroups[itr->mnFieldIndex];
                 const ScDPNumGroupInfo* pNumInfo = pCache->GetNumGroupInfo(itr->mnFieldIndex);
@@ -701,7 +701,7 @@ void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>&
             if (pGrpDim->IsDateDimension() && pNumInfo)
             {
                 // external number group
-                ScDPCacheTable::Criterion aCri;
+                ScDPFilteredCache::Criterion aCri;
                 aCri.mnFieldIndex = nSrcDim;  // use the source dimension, not the group dimension.
                 aCri.mpFilter.reset(
                     new ScDPGroupDateFilter(
@@ -723,11 +723,11 @@ void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>&
                     if (!pGrpItem || !pGrpItem->GetName().IsCaseInsEqual(aName))
                         continue;
 
-                    ScDPCacheTable::Criterion aCri;
+                    ScDPFilteredCache::Criterion aCri;
                     aCri.mnFieldIndex = nSrcDim;
-                    aCri.mpFilter.reset(new ScDPCacheTable::GroupFilter());
-                    ScDPCacheTable::GroupFilter* pGrpFilter =
-                        static_cast<ScDPCacheTable::GroupFilter*>(aCri.mpFilter.get());
+                    aCri.mpFilter.reset(new ScDPFilteredCache::GroupFilter());
+                    ScDPFilteredCache::GroupFilter* pGrpFilter =
+                        static_cast<ScDPFilteredCache::GroupFilter*>(aCri.mpFilter.get());
 
                     pGrpItem->FillGroupFilter(*pGrpFilter);
                     aNewCriteria.push_back(aCri);
@@ -738,16 +738,16 @@ void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>&
     rCriteria.swap(aNewCriteria);
 }
 
-void ScDPGroupTableData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
+void ScDPGroupTableData::FilterCacheTable(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
 {
-    vector<ScDPCacheTable::Criterion> aNewCriteria(rCriteria);
+    vector<ScDPFilteredCache::Criterion> aNewCriteria(rCriteria);
     ModifyFilterCriteria(aNewCriteria);
     pSourceData->FilterCacheTable(aNewCriteria, rCatDims);
 }
 
-void ScDPGroupTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
+void ScDPGroupTableData::GetDrillDownData(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
 {
-    vector<ScDPCacheTable::Criterion> aNewCriteria(rCriteria);
+    vector<ScDPFilteredCache::Criterion> aNewCriteria(rCriteria);
     ModifyFilterCriteria(aNewCriteria);
     pSourceData->GetDrillDownData(aNewCriteria, rCatDims, rData);
 }
@@ -758,7 +758,7 @@ void ScDPGroupTableData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
     // getIsDataLayoutDimension and GetSourceDim are used, so it has to be called
     // with original rInfo, containing dimension indexes of the grouped data.
 
-    const ScDPCacheTable& rCacheTable = pSourceData->GetCacheTable();
+    const ScDPFilteredCache& rCacheTable = pSourceData->GetCacheTable();
     sal_Int32 nRowSize = rCacheTable.getRowSize();
     for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
     {
@@ -783,7 +783,7 @@ void ScDPGroupTableData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
     }
 }
 
-const ScDPCacheTable& ScDPGroupTableData::GetCacheTable() const
+const ScDPFilteredCache& ScDPGroupTableData::GetCacheTable() const
 {
     return pSourceData->GetCacheTable();
 }
diff --git a/sc/source/core/data/dpsdbtab.cxx b/sc/source/core/data/dpsdbtab.cxx
index 696f74d7b920..9b877eebc0d4 100644
--- a/sc/source/core/data/dpsdbtab.cxx
+++ b/sc/source/core/data/dpsdbtab.cxx
@@ -134,14 +134,14 @@ void ScDatabaseDPData::CreateCacheTable()
     aCacheTable.fillTable();
 }
 
-void ScDatabaseDPData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
+void ScDatabaseDPData::FilterCacheTable(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
 {
     CreateCacheTable();
     aCacheTable.filterByPageDimension(
         rCriteria, (IsRepeatIfEmpty() ? rCatDims : boost::unordered_set<sal_Int32>()));
 }
 
-void ScDatabaseDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
+void ScDatabaseDPData::GetDrillDownData(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
 {
     CreateCacheTable();
     sal_Int32 nRowSize = aCacheTable.getRowSize();
@@ -158,7 +158,7 @@ void ScDatabaseDPData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
     CalcResultsFromCacheTable( aCacheTable, rInfo, bAutoShow);
 }
 
-const ScDPCacheTable& ScDatabaseDPData::GetCacheTable() const
+const ScDPFilteredCache& ScDatabaseDPData::GetCacheTable() const
 {
     return aCacheTable;
 }
diff --git a/sc/source/core/data/dpshttab.cxx b/sc/source/core/data/dpshttab.cxx
index 15ea27c1af28..6b6569ca2370 100644
--- a/sc/source/core/data/dpshttab.cxx
+++ b/sc/source/core/data/dpshttab.cxx
@@ -185,14 +185,14 @@ void ScSheetDPData::CreateCacheTable()
     aCacheTable.fillTable(aQuery, bIgnoreEmptyRows, bRepeatIfEmpty);
 }
 
-void ScSheetDPData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
+void ScSheetDPData::FilterCacheTable(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims)
 {
     CreateCacheTable();
     aCacheTable.filterByPageDimension(
         rCriteria, (IsRepeatIfEmpty() ? rCatDims : boost::unordered_set<sal_Int32>()));
 }
 
-void ScSheetDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
+void ScSheetDPData::GetDrillDownData(const vector<ScDPFilteredCache::Criterion>& rCriteria, const boost::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
 {
     CreateCacheTable();
     sal_Int32 nRowSize = aCacheTable.getRowSize();
@@ -209,7 +209,7 @@ void ScSheetDPData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
     CalcResultsFromCacheTable(aCacheTable, rInfo, bAutoShow);
 }
 
-const ScDPCacheTable& ScSheetDPData::GetCacheTable() const
+const ScDPFilteredCache& ScSheetDPData::GetCacheTable() const
 {
     return aCacheTable;
 }
diff --git a/sc/source/core/data/dptabdat.cxx b/sc/source/core/data/dptabdat.cxx
index f150d8d3ef23..79030b83354a 100644
--- a/sc/source/core/data/dptabdat.cxx
+++ b/sc/source/core/data/dptabdat.cxx
@@ -157,7 +157,7 @@ sal_Bool ScDPTableData::HasCommonElement( const ScDPItemData&, long,
     OSL_FAIL("HasCommonElement shouldn't be called for non-group data");
     return false;
 }
-void ScDPTableData::FillRowDataFromCacheTable(sal_Int32 nRow, const ScDPCacheTable& rCacheTable,
+void ScDPTableData::FillRowDataFromCacheTable(sal_Int32 nRow, const ScDPFilteredCache& rCacheTable,
                                         const CalcInfo& rInfo, CalcRowData& rData)
 {
     // column dimensions
@@ -216,7 +216,7 @@ void ScDPTableData::ProcessRowData(CalcInfo& rInfo, CalcRowData& rData, bool bAu
     }
 }
 
-void ScDPTableData::CalcResultsFromCacheTable(const ScDPCacheTable& rCacheTable, CalcInfo& rInfo, bool bAutoShow)
+void ScDPTableData::CalcResultsFromCacheTable(const ScDPFilteredCache& rCacheTable, CalcInfo& rInfo, bool bAutoShow)
 {
     sal_Int32 nRowSize = rCacheTable.getRowSize();
     for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
@@ -234,7 +234,7 @@ void ScDPTableData::CalcResultsFromCacheTable(const ScDPCacheTable& rCacheTable,
     }
 }
 
-void ScDPTableData::GetItemData(const ScDPCacheTable& rCacheTable, sal_Int32 nRow,
+void ScDPTableData::GetItemData(const ScDPFilteredCache& rCacheTable, sal_Int32 nRow,
                                 const vector<long>& rDims, vector<SCROW>& rItemData)
 {
     sal_Int32 nDimSize = rDims.size();
diff --git a/sc/source/core/data/dptabres.cxx b/sc/source/core/data/dptabres.cxx
index 3b34126107a6..b4dfa963f183 100644
--- a/sc/source/core/data/dptabres.cxx
+++ b/sc/source/core/data/dptabres.cxx
@@ -3849,7 +3849,7 @@ void ScDPResultVisibilityData::addVisibleMember(const String& rDimName, const Sc
         rMem.insert(rMemberItem);
 }
 
-void ScDPResultVisibilityData::fillFieldFilters(vector<ScDPCacheTable::Criterion>& rFilters) const
+void ScDPResultVisibilityData::fillFieldFilters(vector<ScDPFilteredCache::Criterion>& rFilters) const
 {
     typedef boost::unordered_map<String, long, ScStringHashCode> FieldNameMapType;
     FieldNameMapType aFieldNames;
@@ -3866,7 +3866,7 @@ void ScDPResultVisibilityData::fillFieldFilters(vector<ScDPCacheTable::Criterion
           itr != itrEnd; ++itr)
     {
         const String& rDimName = itr->first;
-        ScDPCacheTable::Criterion aCri;
+        ScDPFilteredCache::Criterion aCri;
         FieldNameMapType::const_iterator itrField = aFieldNames.find(rDimName);
         if (itrField == aFieldNames.end())
             // This should never happen!
@@ -3874,10 +3874,10 @@ void ScDPResultVisibilityData::fillFieldFilters(vector<ScDPCacheTable::Criterion
 
         long nDimIndex = itrField->second;
         aCri.mnFieldIndex = static_cast<sal_Int32>(nDimIndex);
-        aCri.mpFilter.reset(new ScDPCacheTable::GroupFilter(/*mrSharedString*/));
+        aCri.mpFilter.reset(new ScDPFilteredCache::GroupFilter(/*mrSharedString*/));
 
-        ScDPCacheTable::GroupFilter* pGrpFilter =
-            static_cast<ScDPCacheTable::GroupFilter*>(aCri.mpFilter.get());
+        ScDPFilteredCache::GroupFilter* pGrpFilter =
+            static_cast<ScDPFilteredCache::GroupFilter*>(aCri.mpFilter.get());
 
         const VisibleMemberType& rMem = itr->second;
         for (VisibleMemberType::const_iterator itrMem = rMem.begin(), itrMemEnd = rMem.end();
diff --git a/sc/source/core/data/dptabsrc.cxx b/sc/source/core/data/dptabsrc.cxx
index c3c12149d19e..ba904cb24104 100644
--- a/sc/source/core/data/dptabsrc.cxx
+++ b/sc/source/core/data/dptabsrc.cxx
@@ -431,7 +431,7 @@ Sequence< Sequence<Any> > SAL_CALL ScDPSource::getDrillDownData(const Sequence<s
 {
     long nColumnCount = GetData()->GetColumnCount();
 
-    vector<ScDPCacheTable::Criterion> aFilterCriteria;
+    vector<ScDPFilteredCache::Criterion> aFilterCriteria;
     sal_Int32 nFilterCount = aFilters.getLength();
     for (sal_Int32 i = 0; i < nFilterCount; ++i)
     {
@@ -449,10 +449,10 @@ Sequence< Sequence<Any> > SAL_CALL ScDPSource::getDrillDownData(const Sequence<s
                 {
                     ScDPItemData aItem;
                     pMembers->getByIndex(nIndex)->FillItemData( aItem );
-                    aFilterCriteria.push_back( ScDPCacheTable::Criterion() );
+                    aFilterCriteria.push_back( ScDPFilteredCache::Criterion() );
                     aFilterCriteria.back().mnFieldIndex = nCol;
                     aFilterCriteria.back().mpFilter.reset(
-                        new ScDPCacheTable::SingleFilter(aItem));
+                        new ScDPFilteredCache::SingleFilter(aItem));
                 }
             }
         }
@@ -678,12 +678,13 @@ void ScDPSource::GetCategoryDimensionIndices(boost::unordered_set<sal_Int32>& rC
     rCatDims.swap(aCatDims);
 }
 
-void ScDPSource::FilterCacheTableByPageDimensions()
+void ScDPSource::FilterCacheByPageDimensions()
 {
-    // #i117661# Repeated calls to ScDPCacheTable::filterByPageDimension are invalid because
-    // rows are only hidden, never shown again. If FilterCacheTableByPageDimensions is called
-    // again, the cache table must be re-initialized. Currently, CreateRes_Impl always uses
-    // a fresh cache because ScDBDocFunc::DataPilotUpdate calls InvalidateData.
+    // #i117661# Repeated calls to ScDPFilteredCache::filterByPageDimension
+    // are invalid because rows are only hidden, never shown again. If
+    // FilterCacheByPageDimensions is called again, the cache table must
+    // be re-initialized. Currently, CreateRes_Impl always uses a fresh cache
+    // because ScDBDocFunc::DataPilotUpdate calls InvalidateData.
 
     if (bPageFiltered)
     {
@@ -695,7 +696,7 @@ void ScDPSource::FilterCacheTableByPageDimensions()
     }
 
     // filter table by page dimensions.
-    vector<ScDPCacheTable::Criterion> aCriteria;
+    vector<ScDPFilteredCache::Criterion> aCriteria;
     for (long i = 0; i < nPageDimCount; ++i)
     {
         ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nPageDims[i]);
@@ -705,11 +706,11 @@ void ScDPSource::FilterCacheTableByPageDimensions()
             GetLevelsObject()->getByIndex(0)->GetMembersObject();
 
         long nMemCount = pMems->getCount();
-        ScDPCacheTable::Criterion aFilter;
+        ScDPFilteredCache::Criterion aFilter;
         aFilter.mnFieldIndex = static_cast<sal_Int32>(nField);
-        aFilter.mpFilter.reset(new ScDPCacheTable::GroupFilter(/*rSharedString*/));
-        ScDPCacheTable::GroupFilter* pGrpFilter =
-            static_cast<ScDPCacheTable::GroupFilter*>(aFilter.mpFilter.get());
+        aFilter.mpFilter.reset(new ScDPFilteredCache::GroupFilter(/*rSharedString*/));
+        ScDPFilteredCache::GroupFilter* pGrpFilter =
+            static_cast<ScDPFilteredCache::GroupFilter*>(aFilter.mpFilter.get());
         for (long j = 0; j < nMemCount; ++j)
         {
             ScDPMember* pMem = pMems->getByIndex(j);
@@ -728,10 +729,10 @@ void ScDPSource::FilterCacheTableByPageDimensions()
             continue;
 
         const ScDPItemData& rData = pDim->GetSelectedData();
-        aCriteria.push_back(ScDPCacheTable::Criterion());
-        ScDPCacheTable::Criterion& r = aCriteria.back();
+        aCriteria.push_back(ScDPFilteredCache::Criterion());
+        ScDPFilteredCache::Criterion& r = aCriteria.back();
         r.mnFieldIndex = static_cast<sal_Int32>(nField);
-        r.mpFilter.reset(new ScDPCacheTable::SingleFilter(rData));
+        r.mpFilter.reset(new ScDPFilteredCache::SingleFilter(rData));
     }
     if (!aCriteria.empty())
     {
@@ -913,7 +914,7 @@ void ScDPSource::CreateRes_Impl()
         return;
     }
 
-    FilterCacheTableByPageDimensions();
+    FilterCacheByPageDimensions();
 
     aInfo.aPageDims.reserve(nPageDimCount);
     for (i = 0; i < nPageDimCount; ++i)