sc/source/core/data/dptabdat.cxx

   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 #include <dptabdat.hxx>
  21 #include <dpcache.hxx>
  22 #include <dpfilteredcache.hxx>
  23 #include <dptabres.hxx>
  24
  25 #include <osl/diagnose.h>
  26 #include <tools/date.hxx>
  27
  28
  29 using namespace ::com::sun::star;
  30 using ::std::vector;
  31
  32 ScDPTableData::CalcInfo::CalcInfo() :
  33     pInitState( nullptr ),
  34     pColRoot( nullptr ),
  35     pRowRoot( nullptr )
  36 {
  37 }
  38
  39 ScDPTableData::ScDPTableData(const ScDocument* pDoc) :
  40     mpDoc(pDoc)
  41 {
  42     nLastDateVal = nLastHier = nLastLevel = nLastRet = -1;      // invalid
  43
  44     //TODO: reset before new calculation (in case the base date is changed)
  45 }
  46
  47 ScDPTableData::~ScDPTableData()
  48 {
  49 }
  50
  51 OUString ScDPTableData::GetFormattedString(sal_Int32 nDim, const ScDPItemData& rItem, bool bLocaleIndependent) const
  52 {
  53     const ScDPCache& rCache = GetCacheTable().getCache();
  54     return rCache.GetFormattedString(nDim, rItem, bLocaleIndependent);
  55 }
  56
  57 tools::Long ScDPTableData::GetDatePart( tools::Long nDateVal, tools::Long nHierarchy, tools::Long nLevel )
  58 {
  59     if ( nDateVal == nLastDateVal && nHierarchy == nLastHier && nLevel == nLastLevel )
  60         return nLastRet;
  61
  62     Date aDate( 30,12,1899 );                   //TODO: get from source data (and cache here)
  63     aDate.AddDays( nDateVal);
  64
  65     tools::Long nRet = 0;
  66     switch (nHierarchy)
  67     {
  68         case SC_DAPI_HIERARCHY_QUARTER:
  69             switch (nLevel)
  70             {
  71                 case 0: nRet = aDate.GetYear();                 break;
  72                 case 1: nRet = (aDate.GetMonth()-1) / 3 + 1;    break;
  73                 case 2: nRet = aDate.GetMonth();                break;
  74                 case 3: nRet = aDate.GetDay();                  break;
  75                 default:
  76                     OSL_FAIL("GetDatePart: wrong level");
  77             }
  78             break;
  79         case SC_DAPI_HIERARCHY_WEEK:
  80             switch (nLevel)
  81             {
  82                 //TODO: use settings for different definitions
  83                 case 0: nRet = aDate.GetYear();                 break;      //!...
  84                 case 1: nRet = aDate.GetWeekOfYear();           break;
  85                 case 2: nRet = static_cast<tools::Long>(aDate.GetDayOfWeek());      break;
  86                 default:
  87                     OSL_FAIL("GetDatePart: wrong level");
  88             }
  89             break;
  90         default:
  91             OSL_FAIL("GetDatePart: wrong hierarchy");
  92     }
  93
  94     nLastDateVal = nDateVal;
  95     nLastHier    = nHierarchy;
  96     nLastLevel   = nLevel;
  97     nLastRet     = nRet;
  98
  99     return nRet;
 100 }
 101
 102 bool ScDPTableData::IsRepeatIfEmpty()
 103 {
 104     return false;
 105 }
 106
 107 sal_uInt32 ScDPTableData::GetNumberFormat(sal_Int32)
 108 {
 109     return 0;           // default format
 110 }
 111
 112 bool ScDPTableData::IsBaseForGroup(sal_Int32) const
 113 {
 114     return false;       // always false
 115 }
 116
 117 sal_Int32 ScDPTableData::GetGroupBase(sal_Int32) const
 118 {
 119     return -1;          // always none
 120 }
 121
 122 bool ScDPTableData::IsNumOrDateGroup(sal_Int32) const
 123 {
 124     return false;       // always false
 125 }
 126
 127 bool ScDPTableData::IsInGroup( const ScDPItemData&, sal_Int32,
 128                                const ScDPItemData&, sal_Int32 ) const
 129 {
 130     OSL_FAIL("IsInGroup shouldn't be called for non-group data");
 131     return false;
 132 }
 133
 134 bool ScDPTableData::HasCommonElement( const ScDPItemData&, sal_Int32,
 135                                       const ScDPItemData&, sal_Int32 ) const
 136 {
 137     OSL_FAIL("HasCommonElement shouldn't be called for non-group data");
 138     return false;
 139 }
 140 void ScDPTableData::FillRowDataFromCacheTable(sal_Int32 nRow, const ScDPFilteredCache& rCacheTable,
 141                                         const CalcInfo& rInfo, CalcRowData& rData)
 142 {
 143     // column dimensions
 144     GetItemData(rCacheTable, nRow, rInfo.aColLevelDims, rData.aColData);
 145
 146     // row dimensions
 147     GetItemData(rCacheTable, nRow, rInfo.aRowLevelDims, rData.aRowData);
 148
 149     // page dimensions
 150     GetItemData(rCacheTable, nRow, rInfo.aPageDims, rData.aPageData);
 151
 152     tools::Long nCacheColumnCount = rCacheTable.getCache().GetColumnCount();
 153     sal_Int32 n = rInfo.aDataSrcCols.size();
 154     for (sal_Int32 i = 0; i < n; ++i)
 155     {
 156         tools::Long nDim = rInfo.aDataSrcCols[i];
 157         rData.aValues.emplace_back( );
 158         // #i111435# GetItemData needs dimension indexes including groups,
 159         // so the index must be checked here (groups aren't useful as data fields).
 160         if ( nDim < nCacheColumnCount )
 161         {
 162             ScDPValue& rVal = rData.aValues.back();
 163             rCacheTable.getValue( rVal, static_cast<SCCOL>(nDim), static_cast<SCROW>(nRow));
 164         }
 165     }
 166 }
 167
 168 void ScDPTableData::ProcessRowData(CalcInfo& rInfo, const CalcRowData& rData, bool bAutoShow)
 169 {
 170     if (!bAutoShow)
 171     {
 172         LateInitParams aColParams(rInfo.aColDims, rInfo.aColLevels, false);
 173         LateInitParams aRowParams(rInfo.aRowDims, rInfo.aRowLevels, true);
 174         // root always init child
 175         aColParams.SetInitChild(true);
 176         aColParams.SetInitAllChildren( false);
 177         aRowParams.SetInitChild(true);
 178         aRowParams.SetInitAllChildren( false);
 179
 180         rInfo.pColRoot->LateInitFrom(aColParams, rData.aColData, 0, *rInfo.pInitState);
 181         rInfo.pRowRoot->LateInitFrom(aRowParams, rData.aRowData, 0, *rInfo.pInitState);
 182     }
 183
 184     if ( ( !rInfo.pColRoot->GetChildDimension() || rInfo.pColRoot->GetChildDimension()->IsValidEntry(rData.aColData) ) &&
 185          ( !rInfo.pRowRoot->GetChildDimension() || rInfo.pRowRoot->GetChildDimension()->IsValidEntry(rData.aRowData) ) )
 186     {
 187         //TODO: single process method with ColMembers, RowMembers and data !!!
 188         if (rInfo.pColRoot->GetChildDimension())
 189         {
 190             vector<SCROW> aEmptyData;
 191             rInfo.pColRoot->GetChildDimension()->ProcessData(rData.aColData, nullptr, aEmptyData, rData.aValues);
 192         }
 193
 194         rInfo.pRowRoot->ProcessData(rData.aRowData, rInfo.pColRoot->GetChildDimension(),
 195                                     rData.aColData, rData.aValues);
 196     }
 197 }
 198
 199 void ScDPTableData::CalcResultsFromCacheTable(const ScDPFilteredCache& rCacheTable, CalcInfo& rInfo, bool bAutoShow)
 200 {
 201     sal_Int32 nRowSize = rCacheTable.getRowSize();
 202     for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
 203     {
 204         sal_Int32 nLastRow;
 205         if (!rCacheTable.isRowActive(nRow, &nLastRow))
 206         {
 207             nRow = nLastRow;
 208             continue;
 209         }
 210
 211         CalcRowData aData;
 212         FillRowDataFromCacheTable(nRow, rCacheTable, rInfo, aData);
 213         ProcessRowData(rInfo, aData, bAutoShow);
 214     }
 215 }
 216
 217 void ScDPTableData::GetItemData(const ScDPFilteredCache& rCacheTable, sal_Int32 nRow,
 218                                 const vector<sal_Int32>& rDims, vector<SCROW>& rItemData)
 219 {
 220     sal_Int32 nDimSize = rDims.size();
 221     rItemData.reserve(rItemData.size() + nDimSize);
 222     for (sal_Int32 i = 0; i < nDimSize; ++i)
 223     {
 224         sal_Int32 nDim = rDims[i];
 225
 226         if (getIsDataLayoutDimension(nDim))
 227         {
 228             rItemData.push_back( -1 );
 229             continue;
 230         }
 231
 232         nDim = GetSourceDim( nDim );
 233         if ( nDim >= rCacheTable.getCache().GetColumnCount() )
 234            continue;
 235
 236         SCROW nId= rCacheTable.getCache().GetItemDataId( static_cast<SCCOL>(nDim), static_cast<SCROW>(nRow), IsRepeatIfEmpty());
 237         rItemData.push_back( nId );
 238     }
 239 }
 240
 241 sal_Int32 ScDPTableData::GetMembersCount( sal_Int32 nDim )
 242 {
 243     if ( nDim > MAXCOL )
 244         return 0;
 245     return GetCacheTable().getFieldEntries( nDim ).size();
 246 }
 247
 248 const ScDPItemData* ScDPTableData::GetMemberByIndex( sal_Int32 nDim, sal_Int32 nIndex )
 249 {
 250     if ( nIndex >= GetMembersCount( nDim ) )
 251         return nullptr;
 252
 253     const ::std::vector<SCROW>& nMembers = GetCacheTable().getFieldEntries( nDim );
 254
 255     return GetCacheTable().getCache().GetItemDataById( static_cast<SCCOL>(nDim), static_cast<SCROW>(nMembers[nIndex]) );
 256 }
 257
 258 const ScDPItemData* ScDPTableData::GetMemberById( sal_Int32 nDim, sal_Int32 nId)
 259 {
 260     return GetCacheTable().getCache().GetItemDataById(nDim, static_cast<SCROW>(nId));
 261 }
 262
 263 const std::vector< SCROW >& ScDPTableData::GetColumnEntries( sal_Int32 nColumn )
 264 {
 265     return GetCacheTable().getFieldEntries( nColumn );
 266 }
 267
 268 sal_Int32 ScDPTableData::GetSourceDim( sal_Int32 nDim )
 269 {
 270     return nDim;
 271 }
 272
 273 sal_Int32 ScDPTableData::Compare( sal_Int32 nDim, sal_Int32 nDataId1, sal_Int32 nDataId2)
 274 {
 275     if ( getIsDataLayoutDimension(nDim) )
 276         return 0;
 277
 278     if ( nDataId1 > nDataId2 )
 279         return 1;
 280     else if ( nDataId1 == nDataId2 )
 281         return 0;
 282     else
 283         return -1;
 284 }
 285
 286 #if DUMP_PIVOT_TABLE
 287 void ScDPTableData::Dump() const
 288 {
 289 }
 290 #endif
 291
 292 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */