strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Renamed ScDPTableDataCache to simply ScDPCache.

Browse source 
There were so many classes with 'DPTable' in them it was confusing.
This commit is contained in:
Kohei Yoshida 2011-03-01 00:24:37 -05:00
parent f84427bfdd
commit dddc5972da
14 changed files with 72 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
sc/inc/dpcachetable.hxx
View file

@ -50,7 +50,7 @@ namespace com { namespace sun { namespace star {
class Date;
class ScDPItemData;
class ScDPTableDataCache;
class ScDPCache;
class ScDocument;
class ScRange;
struct ScDPValueData;
@ -121,13 +121,13 @@ public:
Criterion();
};
ScDPCacheTable(ScDPTableDataCache* pCache);
ScDPCacheTable(ScDPCache* pCache);
~ScDPCacheTable();
sal_Int32 getRowSize() const;
sal_Int32 getColSize() const;
const ScDPTableDataCache* getCache() const;
const ScDPCache* getCache() const;
/** Fill the internal table from the cell range provided. This function
assumes that the first row is the column header. */
@ -169,13 +169,13 @@ public:
SCROW getOrder(long nDim, SCROW nIndex) const;
void clear();
bool empty() const;
void setCache(ScDPTableDataCache* p);
void setCache(ScDPCache* p);
private:
ScDPCacheTable();
ScDPCacheTable(const ScDPCacheTable&);
ScDPTableDataCache* getCache();
ScDPCache* getCache();
/**
* Check if a given row meets all specified criteria.
@ -193,7 +193,7 @@ private:
has the index of 0. */
::std::vector<bool> maRowsVisible;
ScDPTableDataCache* mpCache;
ScDPCache* mpCache;
};
#endif

2
sc/inc/dpglobal.hxx
View file

@ -126,7 +126,7 @@ private:
double fValue;
BYTE mbFlag;
friend class ScDPTableDataCache;
friend class ScDPCache;
public:
ScDPItemData() : nNumFormat( 0 ), fValue(0.0), mbFlag( 0 ){}
ScDPItemData( ULONG nNF, const String & rS, double fV, BYTE bF ):nNumFormat(nNF), aString(rS), fValue(fV), mbFlag( bF ){}

4
sc/inc/dpgroup.hxx
View file

@ -75,7 +75,7 @@ public:
const ScDPNumGroupInfo& GetNumInfo() const { return aNumInfo; }
void FillColumnEntries(
SCCOL nSourceDim, const ScDPTableDataCache* pCahe , std::vector<SCROW>& rEntries,
SCCOL nSourceDim, const ScDPCache* pCahe , std::vector<SCROW>& rEntries,
const std::vector<SCROW>& rOriginal) const;
};
@ -166,7 +166,7 @@ public:
const ScDPDateGroupHelper* GetDateHelper() const { return pDateHelper; }
const std::vector<SCROW>& GetNumEntries(
SCCOL nSourceDim, const ScDPTableDataCache* pCache,
SCCOL nSourceDim, const ScDPCache* pCache,
const std::vector< SCROW >& rOriginal) const;
void MakeDateHelper( const ScDPNumGroupInfo& rInfo, sal_Int32 nPart );

2
sc/inc/dpsdbtab.hxx
View file

@ -61,7 +61,7 @@ struct ScImportSourceDesc
bNative == rOther.bNative &&
mpDoc == rOther.mpDoc; }
ScDPTableDataCache* CreateCache() const;
ScDPCache* CreateCache() const;
};
class ScDatabaseDPData : public ScDPTableData

2
sc/inc/dpshttab.hxx
View file

@ -78,7 +78,7 @@ public:
const ScQueryParam& GetQueryParam() const;
bool operator== ( const ScSheetSourceDesc& rOther ) const;
ScDPTableDataCache* CreateCache() const;
ScDPCache* CreateCache() const;
/**
* Check the sanity of the data source range.

12
sc/inc/dptablecache.hxx
View file

@ -42,7 +42,11 @@
struct ScQueryParam;
class SC_DLLPUBLIC ScDPTableDataCache
/**
* This class represents the cached data part of the datapilot cache table
* implementation.
*/
class SC_DLLPUBLIC ScDPCache
{
friend class ScDPCacheTable;
public:
@ -96,10 +100,10 @@ public:
const ScDPItemData* GetItemDataById( long nDim, SCROW nId ) const;
bool operator== ( const ScDPTableDataCache& r ) const;
bool operator== ( const ScDPCache& r ) const;
ScDPTableDataCache(ScDocument* pDoc);
virtual ~ScDPTableDataCache();
ScDPCache(ScDocument* pDoc);
virtual ~ScDPCache();
private:
SCROW GetOrder( long nDim, SCROW nIndex ) const;

2
sc/inc/dptabsrc.hxx
View file

@ -174,7 +174,7 @@ public:
long GetDataDimensionCount();
ScDPDimension* GetDataDimension(long nIndex);
String GetDataDimName(long nIndex);
const ScDPTableDataCache* GetCache();
const ScDPCache* GetCache();
const ScDPItemData* GetItemDataById( long nDim, long nId );
long GetDataLayoutDim(){ return pData->GetColumnCount(); }
SCROW GetMemberId( long nDim, const ScDPItemData& rData );

8
sc/source/core/data/dpcachetable.cxx
View file

@ -158,7 +158,7 @@ ScDPCacheTable::Criterion::Criterion() :
// ----------------------------------------------------------------------------
ScDPCacheTable::ScDPCacheTable(ScDPTableDataCache* pCache) :
ScDPCacheTable::ScDPCacheTable(ScDPCache* pCache) :
mpCache(pCache)
{
}
@ -411,7 +411,7 @@ bool ScDPCacheTable::empty() const
return mpCache == NULL || maFieldEntries.empty();
}
void ScDPCacheTable::setCache(ScDPTableDataCache* p)
void ScDPCacheTable::setCache(ScDPCache* p)
{
delete mpCache;
mpCache = p;
@ -438,12 +438,12 @@ bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCr
return true;
}
const ScDPTableDataCache* ScDPCacheTable::getCache() const
const ScDPCache* ScDPCacheTable::getCache() const
{
return mpCache;
}
ScDPTableDataCache* ScDPCacheTable::getCache()
ScDPCache* ScDPCacheTable::getCache()
{
return mpCache;
}

20
sc/source/core/data/dpgroup.cxx
View file

@ -80,7 +80,7 @@ const sal_Int32 SC_DP_DATE_LAST = 10000;
// ============================================================================
namespace
{
BOOL lcl_Search( SCCOL nSourceDim, const ScDPTableDataCache* pCache , const std::vector< SCROW >& vIdx, SCROW nNew , SCROW& rIndex)
BOOL lcl_Search( SCCOL nSourceDim, const ScDPCache* pCache , const std::vector< SCROW >& vIdx, SCROW nNew , SCROW& rIndex)
{
rIndex = vIdx.size();
BOOL bFound = FALSE;
@ -112,7 +112,7 @@ namespace
return bFound;
}
void lcl_Insert( SCCOL nSourceDim, const ScDPTableDataCache* pCache , std::vector< SCROW >& vIdx, SCROW nNew )
void lcl_Insert( SCCOL nSourceDim, const ScDPCache* pCache , std::vector< SCROW >& vIdx, SCROW nNew )
{
SCROW nIndex = 0;
if ( !lcl_Search( nSourceDim, pCache, vIdx, nNew ,nIndex ) )
@ -120,10 +120,10 @@ namespace
}
template<bool bUpdateData>
SCROW lcl_InsertValue(SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData);
SCROW lcl_InsertValue(SCCOL nSourceDim, const ScDPCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData);
template<>
SCROW lcl_InsertValue<false>(SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData)
SCROW lcl_InsertValue<false>(SCCOL nSourceDim, const ScDPCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData)
{
SCROW nNewID = pCache->GetAdditionalItemID(rData);
lcl_Insert(nSourceDim, pCache, vIdx, nNewID);
@ -131,7 +131,7 @@ namespace
}
template<>
SCROW lcl_InsertValue<true>(SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData)
SCROW lcl_InsertValue<true>(SCCOL nSourceDim, const ScDPCache* pCache, std::vector<SCROW>& vIdx, const ScDPItemData & rData)
{
SCROW nItemId = lcl_InsertValue<false>( nSourceDim, pCache, vIdx, rData );
@ -142,13 +142,13 @@ namespace
}
template<bool bUpdateData>
void lcl_InsertValue ( SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector< SCROW >& vIdx, const String& rString, const double& fValue )
void lcl_InsertValue ( SCCOL nSourceDim, const ScDPCache* pCache, std::vector< SCROW >& vIdx, const String& rString, const double& fValue )
{
lcl_InsertValue<bUpdateData>( nSourceDim, pCache, vIdx, ScDPItemData( rString, fValue, TRUE ) );
}
template<bool bUpdateData>
void lcl_InsertValue ( SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector< SCROW >& vIdx, const String& rString, const double& fValue, sal_Int32 nDatePart )
void lcl_InsertValue ( SCCOL nSourceDim, const ScDPCache* pCache, std::vector< SCROW >& vIdx, const String& rString, const double& fValue, sal_Int32 nDatePart )
{
lcl_InsertValue<bUpdateData>( nSourceDim, pCache, vIdx, ScDPItemData( nDatePart, rString, fValue, ScDPItemData::MK_DATA|ScDPItemData::MK_VAL|ScDPItemData::MK_DATEPART ) );
}
@ -601,7 +601,7 @@ String lcl_GetSpecialDateName( double fValue, bool bFirst, SvNumberFormatter* pF
}
void ScDPDateGroupHelper::FillColumnEntries(
SCCOL nSourceDim, const ScDPTableDataCache* pCache, std::vector<SCROW>& rEntries, const std::vector<SCROW>& rOriginal) const
SCCOL nSourceDim, const ScDPCache* pCache, std::vector<SCROW>& rEntries, const std::vector<SCROW>& rOriginal) const
{
// auto min/max is only used for "Years" part, but the loop is always needed
double fSourceMin = 0.0;
@ -902,7 +902,7 @@ void ScDPNumGroupDimension::MakeDateHelper( const ScDPNumGroupInfo& rInfo, sal_I
}
const std::vector<SCROW>& ScDPNumGroupDimension::GetNumEntries(
SCCOL nSourceDim, const ScDPTableDataCache* pCache, const std::vector<SCROW>& rOriginal) const
SCCOL nSourceDim, const ScDPCache* pCache, const std::vector<SCROW>& rOriginal) const
{
if ( maMemberEntries.empty() )
{
@ -1338,7 +1338,7 @@ void ScDPGroupTableData::FillGroupValues( /*ScDPItemData* pItemData*/ SCROW* pIt
{
long nGroupedColumns = aGroups.size();
const ScDPTableDataCache* pCache = GetCacheTable().getCache();
const ScDPCache* pCache = GetCacheTable().getCache();
for (long nDim=0; nDim<nCount; nDim++)
{
const ScDPDateGroupHelper* pDateHelper = NULL;

2
sc/source/core/data/dpsave.cxx
View file

@ -1305,7 +1305,7 @@ void ScDPSaveDimension::Refresh( const com::sun::star::uno::Reference<
if ( xSource.is() )
{
ScDPSource* pTabSource = static_cast<ScDPSource*>( xSource.get() );
const ScDPTableDataCache* pCache = pTabSource->GetCache();
const ScDPCache* pCache = pTabSource->GetCache();
SCCOL nSrcDim = pCache->GetDimensionIndex( GetName() );

4
sc/source/core/data/dpsdbtab.cxx
View file

@ -75,7 +75,7 @@ using ::com::sun::star::uno::UNO_QUERY;
#define SC_DBPROP_COMMAND "Command"
#define SC_DBPROP_COMMANDTYPE "CommandType"
ScDPTableDataCache* ScImportSourceDesc::CreateCache() const
ScDPCache* ScImportSourceDesc::CreateCache() const
{
if (!mpDoc)
return NULL;
@ -91,7 +91,7 @@ ScDPTableDataCache* ScImportSourceDesc::CreateCache() const
return NULL;
}
ScDPTableDataCache* pCache = new ScDPTableDataCache(mpDoc);
ScDPCache* pCache = new ScDPCache(mpDoc);
uno::Reference<sdbc::XRowSet> xRowSet ;
try

4
sc/source/core/data/dpshttab.cxx
View file

@ -306,7 +306,7 @@ bool ScSheetSourceDesc::operator== (const ScSheetSourceDesc& rOther) const
maQueryParam == rOther.maQueryParam;
}
ScDPTableDataCache* ScSheetSourceDesc::CreateCache() const
ScDPCache* ScSheetSourceDesc::CreateCache() const
{
if (!mpDoc)
return NULL;
@ -318,7 +318,7 @@ ScDPTableDataCache* ScSheetSourceDesc::CreateCache() const
return NULL;
}
ScDPTableDataCache* pCache = new ScDPTableDataCache(mpDoc);
ScDPCache* pCache = new ScDPCache(mpDoc);
pCache->InitFromDoc(mpDoc, GetSourceRange());
return pCache;
}

64
sc/source/core/data/dptablecache.cxx
View file

@ -65,7 +65,7 @@ bool lcl_isDate( ULONG nNumType )
return ((nNumType & NUMBERFORMAT_DATE) != 0) ? 1 : 0;
}
bool lcl_Search( const ScDPTableDataCache::DataListType& list, const ::std::vector<SCROW>& rOrder, const ScDPItemData& item, SCROW& rIndex)
bool lcl_Search( const ScDPCache::DataListType& list, const ::std::vector<SCROW>& rOrder, const ScDPItemData& item, SCROW& rIndex)
{
rIndex = list.size();
bool bFound = false;
@ -360,7 +360,7 @@ void ScDPItemData::SetDate( bool b )
//class ScDPTableDataCache
//To cache the pivot table data source
bool ScDPTableDataCache::operator== ( const ScDPTableDataCache& r ) const
bool ScDPCache::operator== ( const ScDPCache& r ) const
{
if ( GetColumnCount() == r.GetColumnCount() )
{
@ -398,17 +398,17 @@ bool ScDPTableDataCache::operator== ( const ScDPTableDataCache& r ) const
return true;
}
ScDPTableDataCache::ScDPTableDataCache(ScDocument* pDoc) :
ScDPCache::ScDPCache(ScDocument* pDoc) :
mpDoc( pDoc ),
mnColumnCount ( 0 )
{
}
ScDPTableDataCache::~ScDPTableDataCache()
ScDPCache::~ScDPCache()
{
}
bool ScDPTableDataCache::IsValid() const
bool ScDPCache::IsValid() const
{
return !maTableDataValues.empty() && !maSourceData.empty() && mnColumnCount > 0;
}
@ -437,7 +437,7 @@ private:
}
bool ScDPTableDataCache::InitFromDoc(ScDocument* pDoc, const ScRange& rRange)
bool ScDPCache::InitFromDoc(ScDocument* pDoc, const ScRange& rRange)
{
// Make sure the formula cells within the data range are interpreted
// during this call, for this method may be called from the interpretation
@ -486,7 +486,7 @@ bool ScDPTableDataCache::InitFromDoc(ScDocument* pDoc, const ScRange& rRange)
return true;
}
bool ScDPTableDataCache::InitFromDataBase (const Reference<sdbc::XRowSet>& xRowSet, const Date& rNullDate)
bool ScDPCache::InitFromDataBase (const Reference<sdbc::XRowSet>& xRowSet, const Date& rNullDate)
{
if (!xRowSet.is())
// Dont' even waste time to go any further.
@ -555,7 +555,7 @@ bool ScDPTableDataCache::InitFromDataBase (const Reference<sdbc::XRowSet>& xRowS
}
}
ULONG ScDPTableDataCache::GetDimNumType( SCCOL nDim) const
ULONG ScDPCache::GetDimNumType( SCCOL nDim) const
{
DBG_ASSERT( IsValid(), " IsValid() == false " );
DBG_ASSERT( nDim < mnColumnCount && nDim >=0, " dimention out of bound " );
@ -565,7 +565,7 @@ ULONG ScDPTableDataCache::GetDimNumType( SCCOL nDim) const
return GetNumType(maTableDataValues[nDim][0].nNumFormat);
}
bool ScDPTableDataCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam, bool *pSpecial)
bool ScDPCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam, bool *pSpecial)
{
if (!rParam.GetEntry(0).bDoQuery)
return true;
@ -777,17 +777,17 @@ bool ScDPTableDataCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam, boo
return bRet;
}
bool ScDPTableDataCache::IsRowEmpty( SCROW nRow ) const
bool ScDPCache::IsRowEmpty( SCROW nRow ) const
{
return mbEmptyRow[ nRow ];
}
bool ScDPTableDataCache::IsEmptyMember( SCROW nRow, USHORT nColumn ) const
bool ScDPCache::IsEmptyMember( SCROW nRow, USHORT nColumn ) const
{
return !GetItemDataById( nColumn, GetItemDataId( nColumn, nRow, false ) )->IsHasData();
}
bool ScDPTableDataCache::AddData(long nDim, ScDPItemData* pitemData)
bool ScDPCache::AddData(long nDim, ScDPItemData* pitemData)
{
DBG_ASSERT( IsValid(), " IsValid() == false " );
DBG_ASSERT( nDim < mnColumnCount && nDim >=0 , "dimension out of bound" );
@ -823,7 +823,7 @@ bool ScDPTableDataCache::AddData(long nDim, ScDPItemData* pitemData)
}
String ScDPTableDataCache::GetDimensionName( USHORT nColumn ) const
String ScDPCache::GetDimensionName( USHORT nColumn ) const
{
DBG_ASSERT(nColumn < maLabelNames.size()-1 , "ScDPTableDataCache::GetDimensionName");
DBG_ASSERT(maLabelNames.size() == static_cast <USHORT> (mnColumnCount+1), "ScDPTableDataCache::GetDimensionName");
@ -836,7 +836,7 @@ String ScDPTableDataCache::GetDimensionName( USHORT nColumn ) const
return String();
}
void ScDPTableDataCache::AddLabel(ScDPItemData *pData)
void ScDPCache::AddLabel(ScDPItemData *pData)
{
DBG_ASSERT( IsValid(), " IsValid() == false " );
@ -867,7 +867,7 @@ void ScDPTableDataCache::AddLabel(ScDPItemData *pData)
maLabelNames.push_back( pData );
}
SCROW ScDPTableDataCache::GetItemDataId(USHORT nDim, SCROW nRow, bool bRepeatIfEmpty) const
SCROW ScDPCache::GetItemDataId(USHORT nDim, SCROW nRow, bool bRepeatIfEmpty) const
{
DBG_ASSERT( IsValid(), " IsValid() == false " );
DBG_ASSERT( /* nDim >= 0 && */ nDim < mnColumnCount, "ScDPTableDataCache::GetItemDataId " );
@ -881,7 +881,7 @@ SCROW ScDPTableDataCache::GetItemDataId(USHORT nDim, SCROW nRow, bool bRepeatIfE
return maSourceData[nDim][nRow];
}
const ScDPItemData* ScDPTableDataCache::GetItemDataById(long nDim, SCROW nId) const
const ScDPItemData* ScDPCache::GetItemDataById(long nDim, SCROW nId) const
{
if ( nId >= GetRowCount() )
return maAdditionalData.getData( nId - GetRowCount() );
@ -892,7 +892,7 @@ const ScDPItemData* ScDPTableDataCache::GetItemDataById(long nDim, SCROW nId) co
return &maTableDataValues[nDim][nId];
}
SCROW ScDPTableDataCache::GetRowCount() const
SCROW ScDPCache::GetRowCount() const
{
if ( IsValid() )
return maSourceData[0].size();
@ -900,13 +900,13 @@ SCROW ScDPTableDataCache::GetRowCount() const
return 0;
}
const ScDPTableDataCache::DataListType& ScDPTableDataCache::GetDimMemberValues(SCCOL nDim) const
const ScDPCache::DataListType& ScDPCache::GetDimMemberValues(SCCOL nDim) const
{
DBG_ASSERT( nDim>=0 && nDim < mnColumnCount ," nDim < mnColumnCount ");
return maTableDataValues[nDim];
}
SCROW ScDPTableDataCache::GetSortedItemDataId(SCCOL nDim, SCROW nOrder) const
SCROW ScDPCache::GetSortedItemDataId(SCCOL nDim, SCROW nOrder) const
{
DBG_ASSERT ( IsValid(), "IsValid");
DBG_ASSERT( nDim>=0 && nDim < mnColumnCount, "nDim < mnColumnCount");
@ -915,7 +915,7 @@ SCROW ScDPTableDataCache::GetSortedItemDataId(SCCOL nDim, SCROW nOrder) const
return maGlobalOrder[nDim][nOrder];
}
ULONG ScDPTableDataCache::GetNumType(ULONG nFormat) const
ULONG ScDPCache::GetNumType(ULONG nFormat) const
{
SvNumberFormatter* pFormatter = mpDoc->GetFormatTable();
ULONG nType = NUMBERFORMAT_NUMBER;
@ -924,7 +924,7 @@ ULONG ScDPTableDataCache::GetNumType(ULONG nFormat) const
return nType;
}
ULONG ScDPTableDataCache::GetNumberFormat( long nDim ) const
ULONG ScDPCache::GetNumberFormat( long nDim ) const
{
if ( nDim >= mnColumnCount )
return 0;
@ -934,7 +934,7 @@ ULONG ScDPTableDataCache::GetNumberFormat( long nDim ) const
return maTableDataValues[nDim][0].nNumFormat;
}
bool ScDPTableDataCache::IsDateDimension( long nDim ) const
bool ScDPCache::IsDateDimension( long nDim ) const
{
if ( nDim >= mnColumnCount )
return false;
@ -945,19 +945,19 @@ bool ScDPTableDataCache::IsDateDimension( long nDim ) const
}
SCROW ScDPTableDataCache::GetDimMemberCount( SCCOL nDim ) const
SCROW ScDPCache::GetDimMemberCount( SCCOL nDim ) const
{
DBG_ASSERT( nDim>=0 && nDim < mnColumnCount ," ScDPTableDataCache::GetDimMemberCount : out of bound ");
return maTableDataValues[nDim].size();
}
const ScDPItemData* ScDPTableDataCache::GetSortedItemData(SCCOL nDim, SCROW nOrder) const
const ScDPItemData* ScDPCache::GetSortedItemData(SCCOL nDim, SCROW nOrder) const
{
SCROW n = GetSortedItemDataId( nDim, nOrder );
return GetItemDataById( nDim, n );
}
SCCOL ScDPTableDataCache::GetDimensionIndex(String sName) const
SCCOL ScDPCache::GetDimensionIndex(String sName) const
{
for (size_t i = 1; i < maLabelNames.size(); ++i)
{
@ -967,7 +967,7 @@ SCCOL ScDPTableDataCache::GetDimensionIndex(String sName) const
return -1;
}
SCROW ScDPTableDataCache::GetIdByItemData(long nDim, String sItemData ) const
SCROW ScDPCache::GetIdByItemData(long nDim, String sItemData ) const
{
if ( nDim < mnColumnCount && nDim >=0 )
{
@ -982,7 +982,7 @@ SCROW ScDPTableDataCache::GetIdByItemData(long nDim, String sItemData ) const
return GetRowCount() +maAdditionalData.getDataId(rData);
}
SCROW ScDPTableDataCache::GetIdByItemData( long nDim, const ScDPItemData& rData ) const
SCROW ScDPCache::GetIdByItemData( long nDim, const ScDPItemData& rData ) const
{
if ( nDim < mnColumnCount && nDim >=0 )
{
@ -995,19 +995,19 @@ SCROW ScDPTableDataCache::GetIdByItemData( long nDim, const ScDPItemData& rData
return GetRowCount() + maAdditionalData.getDataId(rData);
}
SCROW ScDPTableDataCache::GetAdditionalItemID ( String sItemData ) const
SCROW ScDPCache::GetAdditionalItemID ( String sItemData ) const
{
ScDPItemData rData ( sItemData );
return GetAdditionalItemID( rData );
}
SCROW ScDPTableDataCache::GetAdditionalItemID( const ScDPItemData& rData ) const
SCROW ScDPCache::GetAdditionalItemID( const ScDPItemData& rData ) const
{
return GetRowCount() + maAdditionalData.insertData( rData );
}
SCROW ScDPTableDataCache::GetOrder(long nDim, SCROW nIndex) const
SCROW ScDPCache::GetOrder(long nDim, SCROW nIndex) const
{
DBG_ASSERT( IsValid(), " IsValid() == false " );
DBG_ASSERT( nDim >=0 && nDim < mnColumnCount, "ScDPTableDataCache::GetOrder : out of bound" );
@ -1027,12 +1027,12 @@ SCROW ScDPTableDataCache::GetOrder(long nDim, SCROW nIndex) const
return maIndexOrder[nDim][nIndex];
}
ScDocument* ScDPTableDataCache::GetDoc() const
ScDocument* ScDPCache::GetDoc() const
{
return mpDoc;
};
long ScDPTableDataCache::GetColumnCount() const
long ScDPCache::GetColumnCount() const
{
return mnColumnCount;
}

2
sc/source/core/data/dptabsrc.cxx
View file

@ -2796,7 +2796,7 @@ uno::Any SAL_CALL ScDPMember::getPropertyValue( const rtl::OUString& aPropertyNa
SC_IMPL_DUMMY_PROPERTY_LISTENER( ScDPMember )
const ScDPTableDataCache* ScDPSource::GetCache()
const ScDPCache* ScDPSource::GetCache()
{
DBG_ASSERT( GetData() , "empty ScDPTableData pointer");
return ( GetData()!=NULL) ? GetData()->GetCacheTable().getCache() : NULL ;