| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| #include "compressedarray.hxx" |
| #include "address.hxx" |
| |
| #include <algorithm> |
| |
| template< typename A, typename D > |
| ScCompressedArray<A,D>::ScCompressedArray( A nMaxAccessP, const D& rValue, |
| size_t nDeltaP ) |
| : nCount(1) |
| , nLimit(1) |
| , nDelta( nDeltaP > 0 ? nDeltaP : 1) |
| , pData( new DataEntry[1]) |
| , nMaxAccess( nMaxAccessP) |
| { |
| pData[0].aValue = rValue; |
| pData[0].nEnd = nMaxAccess; |
| } |
| |
| |
| template< typename A, typename D > |
| ScCompressedArray<A,D>::ScCompressedArray( A nMaxAccessP, const D* pDataArray, |
| size_t nDataCount ) |
| : nCount(0) |
| , nLimit( nDataCount) |
| , nDelta( nScCompressedArrayDelta) |
| , pData( new DataEntry[nDataCount]) |
| , nMaxAccess( nMaxAccessP) |
| { |
| D aValue = pDataArray[0]; |
| for (size_t j=0; j<nDataCount; ++j) |
| { |
| if (!(aValue == pDataArray[j])) |
| { |
| pData[nCount].aValue = aValue; |
| pData[nCount].nEnd = j-1; |
| ++nCount; |
| aValue = pDataArray[j]; |
| } |
| } |
| pData[nCount].aValue = aValue; |
| pData[nCount].nEnd = nMaxAccess; |
| ++nCount; |
| Resize( nCount); |
| } |
| |
| |
| template< typename A, typename D > |
| ScCompressedArray<A,D>::~ScCompressedArray() |
| { |
| delete[] pData; |
| } |
| |
| |
| template< typename A, typename D > |
| void ScCompressedArray<A,D>::Resize( size_t nNewLimit) |
| { |
| if ((nCount <= nNewLimit && nNewLimit < nLimit) || nLimit < nNewLimit) |
| { |
| nLimit = nNewLimit; |
| DataEntry* pNewData = new DataEntry[nLimit]; |
| memcpy( pNewData, pData, nCount*sizeof(DataEntry)); |
| delete[] pData; |
| pData = pNewData; |
| } |
| } |
| |
| |
| template< typename A, typename D > |
| size_t ScCompressedArray<A,D>::Search( A nAccess ) const |
| { |
| if (nAccess == 0) |
| return 0; |
| |
| long nLo = 0; |
| long nHi = static_cast<long>(nCount) - 1; |
| long nStart = 0; |
| long nEnd = 0; |
| long i = 0; |
| bool bFound = (nCount == 1); |
| while (!bFound && nLo <= nHi) |
| { |
| i = (nLo + nHi) / 2; |
| if (i > 0) |
| nStart = (long) pData[i - 1].nEnd; |
| else |
| nStart = -1; |
| nEnd = (long) pData[i].nEnd; |
| if (nEnd < (long) nAccess) |
| nLo = ++i; |
| else |
| if (nStart >= (long) nAccess) |
| nHi = --i; |
| else |
| bFound = true; |
| } |
| return (bFound ? static_cast<size_t>(i) : (nAccess < 0 ? 0 : nCount-1)); |
| } |
| |
| |
| template< typename A, typename D > |
| void ScCompressedArray<A,D>::SetValue( A nStart, A nEnd, const D& rValue ) |
| { |
| if (0 <= nStart && nStart <= nMaxAccess && 0 <= nEnd && nEnd <= nMaxAccess |
| && nStart <= nEnd) |
| { |
| if ((nStart == 0) && (nEnd == nMaxAccess)) |
| Reset( rValue); |
| else |
| { |
| // Create a temporary copy in case we got a reference passed that |
| // points to a part of the array to be reallocated. |
| D aNewVal( rValue); |
| size_t nNeeded = nCount + 2; |
| if (nLimit < nNeeded) |
| { |
| nLimit += nDelta; |
| if (nLimit < nNeeded) |
| nLimit = nNeeded; |
| DataEntry* pNewData = new DataEntry[nLimit]; |
| memcpy( pNewData, pData, nCount*sizeof(DataEntry)); |
| delete[] pData; |
| pData = pNewData; |
| } |
| |
| size_t ni; // number of leading entries |
| size_t nInsert; // insert position (nMaxAccess+1 := no insert) |
| bool bCombined = false; |
| bool bSplit = false; |
| if (nStart > 0) |
| { |
| // skip leading |
| ni = Search( nStart); |
| |
| nInsert = nMaxAccess+1; |
| if (!(pData[ni].aValue == aNewVal)) |
| { |
| if (ni == 0 || (pData[ni-1].nEnd < nStart - 1)) |
| { // may be a split or a simple insert or just a shrink, |
| // row adjustment is done further down |
| if (pData[ni].nEnd > nEnd) |
| bSplit = true; |
| ni++; |
| nInsert = ni; |
| } |
| else if (ni > 0 && pData[ni-1].nEnd == nStart - 1) |
| nInsert = ni; |
| } |
| if (ni > 0 && pData[ni-1].aValue == aNewVal) |
| { // combine |
| pData[ni-1].nEnd = nEnd; |
| nInsert = nMaxAccess+1; |
| bCombined = true; |
| } |
| } |
| else |
| { |
| nInsert = 0; |
| ni = 0; |
| } |
| |
| size_t nj = ni; // stop position of range to replace |
| while (nj < nCount && pData[nj].nEnd <= nEnd) |
| nj++; |
| if (!bSplit) |
| { |
| if (nj < nCount && pData[nj].aValue == aNewVal) |
| { // combine |
| if (ni > 0) |
| { |
| if (pData[ni-1].aValue == aNewVal) |
| { // adjacent entries |
| pData[ni-1].nEnd = pData[nj].nEnd; |
| nj++; |
| } |
| else if (ni == nInsert) |
| pData[ni-1].nEnd = nStart - 1; // shrink |
| } |
| nInsert = nMaxAccess+1; |
| bCombined = true; |
| } |
| else if (ni > 0 && ni == nInsert) |
| pData[ni-1].nEnd = nStart - 1; // shrink |
| } |
| if (ni < nj) |
| { // remove middle entries |
| if (!bCombined) |
| { // replace one entry |
| pData[ni].nEnd = nEnd; |
| pData[ni].aValue = aNewVal; |
| ni++; |
| nInsert = nMaxAccess+1; |
| } |
| if (ni < nj) |
| { // remove entries |
| memmove( pData + ni, pData + nj, |
| (nCount - nj) * sizeof(DataEntry)); |
| nCount -= nj - ni; |
| } |
| } |
| |
| if (nInsert < static_cast<size_t>(nMaxAccess+1)) |
| { // insert or append new entry |
| if (nInsert <= nCount) |
| { |
| if (!bSplit) |
| memmove( pData + nInsert + 1, pData + nInsert, |
| (nCount - nInsert) * sizeof(DataEntry)); |
| else |
| { |
| memmove( pData + nInsert + 2, pData + nInsert, |
| (nCount - nInsert) * sizeof(DataEntry)); |
| pData[nInsert+1] = pData[nInsert-1]; |
| nCount++; |
| } |
| } |
| if (nInsert) |
| pData[nInsert-1].nEnd = nStart - 1; |
| pData[nInsert].nEnd = nEnd; |
| pData[nInsert].aValue = aNewVal; |
| nCount++; |
| } |
| } |
| } |
| } |
| |
| |
| template< typename A, typename D > |
| void ScCompressedArray<A,D>::CopyFrom( const ScCompressedArray<A,D>& rArray, A nStart, |
| A nEnd, long nSourceDy ) |
| { |
| size_t nIndex; |
| A nRegionEnd; |
| for (A j=nStart; j<=nEnd; ++j) |
| { |
| const D& rValue = (j==nStart ? |
| rArray.GetValue( j+nSourceDy, nIndex, nRegionEnd) : |
| rArray.GetNextValue( nIndex, nRegionEnd)); |
| nRegionEnd -= nSourceDy; |
| if (nRegionEnd > nEnd) |
| nRegionEnd = nEnd; |
| SetValue( j, nRegionEnd, rValue); |
| j = nRegionEnd; |
| } |
| } |
| |
| |
| template< typename A, typename D > |
| const D& ScCompressedArray<A,D>::Insert( A nStart, size_t nAccessCount ) |
| { |
| size_t nIndex = Search( nStart); |
| // No real insertion is needed, simply extend the one entry and adapt all |
| // following. In case nStart points to the start row of an entry, extend |
| // the previous entry (inserting before nStart). |
| if (nIndex > 0 && pData[nIndex-1].nEnd+1 == nStart) |
| --nIndex; |
| const D& rValue = pData[nIndex].aValue; // the value "copied" |
| do |
| { |
| pData[nIndex].nEnd += nAccessCount; |
| if (pData[nIndex].nEnd >= nMaxAccess) |
| { |
| pData[nIndex].nEnd = nMaxAccess; |
| nCount = nIndex + 1; // discard trailing entries |
| } |
| } while (++nIndex < nCount); |
| return rValue; |
| } |
| |
| |
| template< typename A, typename D > |
| void ScCompressedArray<A,D>::Remove( A nStart, size_t nAccessCount ) |
| { |
| A nEnd = nStart + nAccessCount - 1; |
| size_t nIndex = Search( nStart); |
| // equalize/combine/remove all entries in between |
| if (nEnd > pData[nIndex].nEnd) |
| SetValue( nStart, nEnd, pData[nIndex].aValue); |
| // remove an exactly matching entry by shifting up all following by one |
| if ((nStart == 0 || (nIndex > 0 && nStart == pData[nIndex-1].nEnd+1)) && |
| pData[nIndex].nEnd == nEnd && nIndex < nCount-1) |
| { |
| // In case removing an entry results in two adjacent entries with |
| // identical data, combine them into one. This is also necessary to |
| // make the algorithm used in SetValue() work correctly, it relies on |
| // the fact that consecutive values actually differ. |
| size_t nRemove; |
| if (nIndex > 0 && pData[nIndex-1].aValue == pData[nIndex+1].aValue) |
| { |
| nRemove = 2; |
| --nIndex; |
| } |
| else |
| nRemove = 1; |
| memmove( pData + nIndex, pData + nIndex + nRemove, (nCount - (nIndex + |
| nRemove)) * sizeof(DataEntry)); |
| nCount -= nRemove; |
| } |
| // adjust end rows, nIndex still being valid |
| do |
| { |
| pData[nIndex].nEnd -= nAccessCount; |
| } while (++nIndex < nCount); |
| pData[nCount-1].nEnd = nMaxAccess; |
| } |
| |
| |
| template< typename A, typename D > |
| A ScCompressedArray<A,D>::GetLastUnequalAccess( A nStart, const D& rCompare ) |
| { |
| A nEnd = ::std::numeric_limits<A>::max(); |
| size_t nIndex = nCount-1; |
| while (1) |
| { |
| if (pData[nIndex].aValue != rCompare) |
| { |
| nEnd = pData[nIndex].nEnd; |
| break; // while |
| } |
| else |
| { |
| if (nIndex > 0) |
| { |
| --nIndex; |
| if (pData[nIndex].nEnd < nStart) |
| break; // while |
| } |
| else |
| break; // while |
| } |
| } |
| return nEnd; |
| } |
| |
| |
| // === ScSummableCompressedArray ============================================= |
| |
| template< typename A, typename D > |
| unsigned long ScSummableCompressedArray<A,D>::SumValues( A nStart, A nEnd ) const |
| { |
| size_t nIndex = this->Search( nStart); |
| unsigned long nSum = SumValuesContinuation( nStart, nEnd, nIndex); |
| if (nEnd > this->nMaxAccess) |
| nSum += this->pData[this->nCount-1].aValue * (nEnd - this->nMaxAccess); |
| return nSum; |
| } |
| |
| |
| template< typename A, typename D > |
| unsigned long ScSummableCompressedArray<A,D>::SumValuesContinuation( |
| A nStart, A nEnd, size_t& nIndex ) const |
| { |
| unsigned long nSum = 0; |
| A nS = nStart; |
| while (nIndex < this->nCount && nS <= nEnd) |
| { |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| // FIXME: test for overflow in a single region? |
| unsigned long nNew = (unsigned long) this->pData[nIndex].aValue * (nE - nS + 1); |
| nSum += nNew; |
| if (nSum < nNew) |
| return ::std::numeric_limits<unsigned long>::max(); |
| nS = nE + 1; |
| if (nS <= nEnd) |
| ++nIndex; |
| } |
| return nSum; |
| } |
| |
| |
| template< typename A, typename D > |
| unsigned long ScSummableCompressedArray<A,D>::SumScaledValuesContinuation( |
| A nStart, A nEnd, size_t& nIndex, double fScale ) const |
| { |
| unsigned long nSum = 0; |
| A nS = nStart; |
| while (nIndex < this->nCount && nS <= nEnd) |
| { |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| unsigned long nScaledVal = (unsigned long) (this->pData[nIndex].aValue * fScale); |
| // FIXME: test for overflow in a single region? |
| unsigned long nNew = nScaledVal * (nE - nS + 1); |
| nSum += nNew; |
| if (nSum < nNew) |
| return ::std::numeric_limits<unsigned long>::max(); |
| nS = nE + 1; |
| if (nS <= nEnd) |
| ++nIndex; |
| } |
| return nSum; |
| } |
| |
| |
| // === ScBitMaskCompressedArray ============================================== |
| |
| template< typename A, typename D > |
| void ScBitMaskCompressedArray<A,D>::AndValue( A nStart, A nEnd, |
| const D& rValueToAnd ) |
| { |
| if (nStart > nEnd) |
| return; |
| |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue & rValueToAnd) != this->pData[nIndex].aValue) |
| { |
| A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart); |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| this->SetValue( nS, nE, this->pData[nIndex].aValue & rValueToAnd); |
| if (nE >= nEnd) |
| break; // while |
| nIndex = this->Search( nE + 1); |
| } |
| else if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| else |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| } |
| |
| |
| template< typename A, typename D > |
| void ScBitMaskCompressedArray<A,D>::OrValue( A nStart, A nEnd, |
| const D& rValueToOr ) |
| { |
| if (nStart > nEnd) |
| return; |
| |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue | rValueToOr) != this->pData[nIndex].aValue) |
| { |
| A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart); |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| this->SetValue( nS, nE, this->pData[nIndex].aValue | rValueToOr); |
| if (nE >= nEnd) |
| break; // while |
| nIndex = this->Search( nE + 1); |
| } |
| else if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| else |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| } |
| |
| |
| template< typename A, typename D > |
| void ScBitMaskCompressedArray<A,D>::CopyFromAnded( |
| const ScBitMaskCompressedArray<A,D>& rArray, A nStart, A nEnd, |
| const D& rValueToAnd, long nSourceDy ) |
| { |
| size_t nIndex; |
| A nRegionEnd; |
| for (A j=nStart; j<=nEnd; ++j) |
| { |
| const D& rValue = (j==nStart ? |
| rArray.GetValue( j+nSourceDy, nIndex, nRegionEnd) : |
| rArray.GetNextValue( nIndex, nRegionEnd)); |
| nRegionEnd -= nSourceDy; |
| if (nRegionEnd > nEnd) |
| nRegionEnd = nEnd; |
| this->SetValue( j, nRegionEnd, rValue & rValueToAnd); |
| j = nRegionEnd; |
| } |
| } |
| |
| |
| template< typename A, typename D > |
| void ScBitMaskCompressedArray<A,D>::CopyFromOred( |
| const ScBitMaskCompressedArray<A,D>& rArray, A nStart, A nEnd, |
| const D& rValueToOr, long nSourceDy ) |
| { |
| size_t nIndex; |
| A nRegionEnd; |
| for (A j=nStart; j<=nEnd; ++j) |
| { |
| const D& rValue = (j==nStart ? |
| rArray.GetValue( j+nSourceDy, nIndex, nRegionEnd) : |
| rArray.GetNextValue( nIndex, nRegionEnd)); |
| nRegionEnd -= nSourceDy; |
| if (nRegionEnd > nEnd) |
| nRegionEnd = nEnd; |
| this->SetValue( j, nRegionEnd, rValue | rValueToOr); |
| j = nRegionEnd; |
| } |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::GetBitStateStart( A nEnd, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| A nStart = ::std::numeric_limits<A>::max(); |
| size_t nIndex = this->Search( nEnd); |
| while ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| { |
| if (nIndex > 0) |
| { |
| --nIndex; |
| nStart = this->pData[nIndex].nEnd + 1; |
| } |
| else |
| { |
| nStart = 0; |
| break; // while |
| } |
| } |
| return nStart; |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::GetBitStateEnd( A nStart, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| A nEnd = ::std::numeric_limits<A>::max(); |
| size_t nIndex = this->Search( nStart); |
| while (nIndex < this->nCount && (this->pData[nIndex].aValue & rBitMask) == |
| rMaskedCompare) |
| { |
| nEnd = this->pData[nIndex].nEnd; |
| ++nIndex; |
| } |
| return nEnd; |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::GetFirstForCondition( A nStart, A nEnd, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| { |
| A nFound = nIndex > 0 ? this->pData[nIndex-1].nEnd + 1 : 0; |
| return ::std::max( nFound, nStart); |
| } |
| if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| return ::std::numeric_limits<A>::max(); |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::GetLastForCondition( A nStart, A nEnd, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| size_t nIndex = this->Search( nEnd); |
| while (1) |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| return ::std::min( this->pData[nIndex].nEnd, nEnd); |
| |
| if (nIndex > 0) |
| { |
| --nIndex; |
| if (this->pData[nIndex].nEnd < nStart) |
| break; // while |
| } |
| else |
| break; // while |
| } |
| return ::std::numeric_limits<A>::max(); |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::CountForCondition( A nStart, A nEnd, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| A nRet = 0; |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| { |
| A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart); |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| nRet += nE - nS + 1; |
| } |
| if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| return nRet; |
| } |
| |
| |
| template< typename A, typename D > |
| size_t ScBitMaskCompressedArray<A,D>::FillArrayForCondition( A nStart, A nEnd, |
| const D& rBitMask, const D& rMaskedCompare, |
| A * pArray, size_t nArraySize ) const |
| { |
| size_t nUsed = 0; |
| size_t nIndex = this->Search( nStart); |
| while (nIndex < this->nCount && nUsed < nArraySize) |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| { |
| A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart); |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| while (nS <= nE && nUsed < nArraySize) |
| pArray[nUsed++] = nS++; |
| } |
| if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| ++nIndex; |
| } |
| return nUsed; |
| } |
| |
| |
| template< typename A, typename D > |
| bool ScBitMaskCompressedArray<A,D>::HasCondition( A nStart, A nEnd, |
| const D& rBitMask, const D& rMaskedCompare ) const |
| { |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare) |
| return true; |
| if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| return false; |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::CountForAnyBitCondition( A nStart, A nEnd, |
| const D& rBitMask ) const |
| { |
| A nRet = 0; |
| size_t nIndex = this->Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) != 0) |
| { |
| A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart); |
| A nE = ::std::min( this->pData[nIndex].nEnd, nEnd); |
| nRet += nE - nS + 1; |
| } |
| if (this->pData[nIndex].nEnd >= nEnd) |
| break; // while |
| ++nIndex; |
| } while (nIndex < this->nCount); |
| return nRet; |
| } |
| |
| |
| template< typename A, typename D > |
| A ScBitMaskCompressedArray<A,D>::GetLastAnyBitAccess( A nStart, |
| const D& rBitMask ) const |
| { |
| A nEnd = ::std::numeric_limits<A>::max(); |
| size_t nIndex = this->nCount-1; |
| while (1) |
| { |
| if ((this->pData[nIndex].aValue & rBitMask) != 0) |
| { |
| nEnd = this->pData[nIndex].nEnd; |
| break; // while |
| } |
| else |
| { |
| if (nIndex > 0) |
| { |
| --nIndex; |
| if (this->pData[nIndex].nEnd < nStart) |
| break; // while |
| } |
| else |
| break; // while |
| } |
| } |
| return nEnd; |
| } |
| |
| |
| template< typename A, typename D > |
| template< typename S > |
| unsigned long ScBitMaskCompressedArray<A,D>::SumCoupledArrayForCondition( |
| A nStart, A nEnd, const D& rBitMask, const D& rMaskedCompare, |
| const ScSummableCompressedArray<A,S>& rArray ) const |
| { |
| unsigned long nSum = 0; |
| A nS = nStart; |
| size_t nIndex1 = this->Search( nStart); |
| size_t nIndex2 = rArray.Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex1].aValue & rBitMask) == rMaskedCompare) |
| { |
| while (nIndex2 < rArray.GetEntryCount() && |
| rArray.GetDataEntry(nIndex2).nEnd < nS) |
| ++nIndex2; |
| unsigned long nNew = rArray.SumValuesContinuation( nS, |
| ::std::min( this->pData[nIndex1].nEnd, nEnd), nIndex2); |
| nSum += nNew; |
| if (nSum < nNew) |
| return ::std::numeric_limits<unsigned long>::max(); |
| } |
| nS = this->pData[nIndex1].nEnd + 1; |
| ++nIndex1; |
| } while (nIndex1 < this->nCount && nS <= nEnd); |
| if (nEnd > this->nMaxAccess && |
| (this->pData[this->GetEntryCount()-1].aValue & rBitMask) == rMaskedCompare) |
| nSum += rArray.GetDataEntry(rArray.GetEntryCount()-1).aValue * (nEnd - |
| this->nMaxAccess); |
| return nSum; |
| } |
| |
| |
| template< typename A, typename D > |
| template< typename S > |
| unsigned long ScBitMaskCompressedArray<A,D>::SumScaledCoupledArrayForCondition( |
| A nStart, A nEnd, const D& rBitMask, const D& rMaskedCompare, |
| const ScSummableCompressedArray<A,S>& rArray, double fScale ) const |
| { |
| unsigned long nSum = 0; |
| A nS = nStart; |
| size_t nIndex1 = this->Search( nStart); |
| size_t nIndex2 = rArray.Search( nStart); |
| do |
| { |
| if ((this->pData[nIndex1].aValue & rBitMask) == rMaskedCompare) |
| { |
| while (nIndex2 < rArray.GetEntryCount() && |
| rArray.GetDataEntry(nIndex2).nEnd < nS) |
| ++nIndex2; |
| unsigned long nNew = rArray.SumScaledValuesContinuation( nS, |
| ::std::min( this->pData[nIndex1].nEnd, nEnd), nIndex2, fScale); |
| nSum += nNew; |
| if (nSum < nNew) |
| return ::std::numeric_limits<unsigned long>::max(); |
| } |
| nS = this->pData[nIndex1].nEnd + 1; |
| ++nIndex1; |
| } while (nIndex1 < this->nCount && nS <= nEnd); |
| if (nEnd > this->nMaxAccess && |
| (this->pData[this->GetEntryCount()-1].aValue & rBitMask) == rMaskedCompare) |
| nSum += (unsigned long) |
| (rArray.GetDataEntry(rArray.GetEntryCount()-1).aValue * fScale) * |
| (nEnd - this->nMaxAccess); |
| return nSum; |
| } |
| |
| |
| // === ScCompressedArrayIterator ============================================= |
| |
| template< typename A, typename D > |
| template< typename X > |
| void ScCompressedArrayIterator<A,D>::Follow( |
| const ScCompressedArrayIterator<A,X>& rIter ) |
| { |
| nCurrent = rIter.GetPos(); |
| if (GetRangeStart() <= nCurrent && nCurrent <= GetRangeEnd()) |
| ; // nothing |
| else if (nCurrent > GetRangeEnd()) |
| { |
| A nPos = nCurrent; // nCurrent gets changed in NextRange() |
| bool bAdv; |
| do |
| { |
| bAdv = NextRange(); |
| } while (bAdv && GetRangeEnd() < nPos); |
| nCurrent = nPos; |
| } |
| else |
| nIndex = rArray.Search( nCurrent); |
| } |
| |
| |
| // === ScCoupledCompressedArrayIterator ====================================== |
| |
| template< typename A, typename D, typename S > |
| ScCoupledCompressedArrayIterator<A,D,S>::ScCoupledCompressedArrayIterator( |
| const ScBitMaskCompressedArray<A,D> & rArray1, A nStart, A nEnd, |
| const D& rBitMaskP, const D& rMaskedCompareP, |
| const ScCompressedArray<A,S> & rArray2 ) |
| : aIter1( rArray1, nStart, nEnd ) |
| , aIter2( rArray2, nStart, nEnd ) |
| , rBitMask( rBitMaskP ) |
| , rMaskedCompare( rMaskedCompareP ) |
| { |
| InitLimits(); |
| } |
| |
| |
| template< typename A, typename D, typename S > |
| void ScCoupledCompressedArrayIterator<A,D,S>::InitLimits() |
| { |
| bool bFound = true; |
| bool bMoved = false; |
| while (bFound && ((*aIter1 & rBitMask) != rMaskedCompare)) |
| { |
| bFound = aIter1.NextRange(); |
| bMoved = true; |
| } |
| if (bMoved && bFound) |
| aIter2.Follow( aIter1); |
| } |
| |
| |
| template< typename A, typename D, typename S > |
| void ScCoupledCompressedArrayIterator<A,D,S>::NewLimits( A nStart, A nEnd ) |
| { |
| aIter1.NewLimits( nStart, nEnd); |
| aIter2.NewLimits( nStart, nEnd); |
| InitLimits(); |
| } |
| |
| |
| template< typename A, typename D, typename S > |
| bool ScCoupledCompressedArrayIterator<A,D,S>::NextRange() |
| { |
| bool bAdv; |
| if (aIter1.GetRangeEnd() <= aIter2.GetRangeEnd()) |
| { |
| // Advance bit mask array until condition is met, coupled array |
| // follows. |
| do |
| { |
| bAdv = aIter1.NextRange(); |
| } while (bAdv && ((*aIter1 & rBitMask) != rMaskedCompare)); |
| if (bAdv) |
| aIter2.Follow( aIter1); |
| } |
| else |
| { |
| // Make coupled array catch up with bit mask array. |
| do |
| { |
| bAdv = aIter2.NextRange(); |
| } while (bAdv && aIter2.GetRangeEnd() < aIter1.GetRangeStart()); |
| if (bAdv) |
| aIter1.Follow( aIter2); // synchronize aIter1.nCurrent |
| } |
| return operator bool(); |
| } |
| |
| |
| template< typename A, typename D, typename S > |
| void ScCoupledCompressedArrayIterator<A,D,S>::Resync( A nPos ) |
| { |
| aIter1.Resync( nPos); |
| aIter2.Resync( nPos); |
| InitLimits(); |
| } |
| |
| |
| // === Force instantiation of specializations ================================ |
| |
| template class ScCompressedArray< SCROW, sal_uInt16>; // heights, base class |
| template class ScSummableCompressedArray< SCROW, sal_uInt16>; // heights |
| template class ScCompressedArray< SCROW, sal_uInt8>; // flags, base class |
| template class ScBitMaskCompressedArray< SCROW, sal_uInt8>; // flags |
| template unsigned long ScBitMaskCompressedArray< SCROW, |
| sal_uInt8>::SumCoupledArrayForCondition( SCROW, SCROW, const sal_uInt8&, const sal_uInt8&, |
| const ScSummableCompressedArray< SCROW, sal_uInt16>&) const; |
| template unsigned long ScBitMaskCompressedArray< SCROW, |
| sal_uInt8>::SumScaledCoupledArrayForCondition( SCROW, SCROW, const sal_uInt8&, |
| const sal_uInt8&, const ScSummableCompressedArray< SCROW, sal_uInt16>&, |
| double) const; |
| template void ScCompressedArrayIterator< SCROW, sal_uInt16>::Follow( |
| const ScCompressedArrayIterator< SCROW, sal_uInt8>&); |
| template class ScCoupledCompressedArrayIterator< SCROW, sal_uInt8, sal_uInt16>; |
| |
| // === EOF =================================================================== |
