sc/source/core/data/segmenttree.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: compressedarray.hxx,v $
  10  * $Revision: 1.7.32.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 #include "segmenttree.hxx"
  35 #include "mdds/flatsegmenttree.hxx"
  36
  37 #define USE_TREE_SEARCH 1
  38
  39 class ScFlatBoolSegmentsImpl
  40 {
  41 public:
  42     struct RangeData
  43     {
  44         SCCOLROW    mnPos1;
  45         SCCOLROW    mnPos2;
  46         bool        mbValue;
  47     };
  48     ScFlatBoolSegmentsImpl(SCCOLROW nMax);
  49     ~ScFlatBoolSegmentsImpl();
  50
  51     void setTrue(SCCOLROW nPos1, SCCOLROW nPos2);
  52     void setFalse(SCCOLROW nPos1, SCCOLROW nPos2);
  53     bool getValue(SCCOLROW nPos);
  54     bool getRangeData(SCCOLROW nPos, RangeData& rData);
  55     void removeSegment(SCCOLROW nPos1, SCCOLROW nPos2);
  56     void insertSegment(SCCOLROW nPos, SCCOLROW nSize, bool bSkipStartBoundary);
  57
  58 private:
  59     ScFlatBoolSegmentsImpl();
  60     ScFlatBoolSegmentsImpl(const ScFlatBoolSegmentsImpl&);
  61
  62     ::mdds::flat_segment_tree<SCCOLROW, bool> maSegments;
  63 };
  64
  65 ScFlatBoolSegmentsImpl::ScFlatBoolSegmentsImpl(SCCOLROW nMax) :
  66     maSegments(0, nMax+1, false)
  67 {
  68 }
  69
  70 ScFlatBoolSegmentsImpl::~ScFlatBoolSegmentsImpl()
  71 {
  72 }
  73
  74 void ScFlatBoolSegmentsImpl::setTrue(SCCOLROW nPos1, SCCOLROW nPos2)
  75 {
  76     maSegments.insert_segment(nPos1, nPos2+1, true);
  77 }
  78
  79 void ScFlatBoolSegmentsImpl::setFalse(SCCOLROW nPos1, SCCOLROW nPos2)
  80 {
  81     maSegments.insert_segment(nPos1, nPos2+1, false);
  82 }
  83
  84 bool ScFlatBoolSegmentsImpl::getValue(SCCOLROW nPos)
  85 {
  86     bool bValue = false;
  87 #if USE_TREE_SEARCH
  88     if (!maSegments.is_tree_valid())
  89         maSegments.build_tree();
  90
  91     maSegments.search_tree(nPos, bValue);
  92 #else
  93     maSegments.search(nPos, bValue);
  94 #endif
  95     return bValue;
  96 }
  97
  98 bool ScFlatBoolSegmentsImpl::getRangeData(SCCOLROW nPos, RangeData& rData)
  99 {
 100 #if USE_TREE_SEARCH
 101     if (!maSegments.is_tree_valid())
 102         maSegments.build_tree();
 103 #endif
 104
 105     bool bValue;
 106     SCCOLROW nPos1, nPos2;
 107 #if USE_TREE_SEARCH
 108     if (!maSegments.search_tree(nPos, bValue, &nPos1, &nPos2))
 109         return false;
 110 #else
 111     if (!maSegments.search(nPos, bValue, &nPos1, &nPos2))
 112         return false;
 113 #endif
 114
 115     rData.mnPos1 = nPos1;
 116     rData.mnPos2 = nPos2-1; // end point is not inclusive.
 117     rData.mbValue = bValue;
 118     return true;
 119 }
 120
 121 void ScFlatBoolSegmentsImpl::removeSegment(SCCOLROW nPos1, SCCOLROW nPos2)
 122 {
 123     maSegments.shift_segment_left(nPos1, nPos2);
 124 }
 125
 126 void ScFlatBoolSegmentsImpl::insertSegment(SCCOLROW nPos, SCCOLROW nSize, bool bSkipStartBoundary)
 127 {
 128     maSegments.shift_segment_right(nPos, nSize, bSkipStartBoundary);
 129 }
 130
 131 // ============================================================================
 132
 133 ScFlatBoolRowSegments::ScFlatBoolRowSegments() :
 134     mpImpl(new ScFlatBoolSegmentsImpl(static_cast<SCCOLROW>(MAXROW)))
 135 {
 136 }
 137
 138 ScFlatBoolRowSegments::~ScFlatBoolRowSegments()
 139 {
 140 }
 141
 142 void ScFlatBoolRowSegments::setTrue(SCROW nRow1, SCROW nRow2)
 143 {
 144     mpImpl->setTrue(static_cast<SCCOLROW>(nRow1), static_cast<SCCOLROW>(nRow2));
 145 }
 146
 147 void ScFlatBoolRowSegments::setFalse(SCROW nRow1, SCROW nRow2)
 148 {
 149     mpImpl->setFalse(static_cast<SCCOLROW>(nRow1), static_cast<SCCOLROW>(nRow2));
 150 }
 151
 152 bool ScFlatBoolRowSegments::getValue(SCROW nRow)
 153 {
 154     return mpImpl->getValue(static_cast<SCCOLROW>(nRow));
 155 }
 156
 157 bool ScFlatBoolRowSegments::getRangeData(SCROW nRow, RangeData& rData)
 158 {
 159     ScFlatBoolSegmentsImpl::RangeData aData;
 160     if (!mpImpl->getRangeData(static_cast<SCCOLROW>(nRow), aData))
 161         return false;
 162
 163     rData.mbValue = aData.mbValue;
 164     rData.mnRow1  = static_cast<SCROW>(aData.mnPos1);
 165     rData.mnRow2  = static_cast<SCROW>(aData.mnPos2);
 166     return true;
 167 }
 168
 169 void ScFlatBoolRowSegments::removeSegment(SCROW nRow1, SCROW nRow2)
 170 {
 171     mpImpl->removeSegment(static_cast<SCCOLROW>(nRow1), static_cast<SCCOLROW>(nRow2));
 172 }
 173
 174 void ScFlatBoolRowSegments::insertSegment(SCROW nRow, SCROW nSize, bool bSkipStartBoundary)
 175 {
 176     mpImpl->insertSegment(static_cast<SCCOLROW>(nRow), static_cast<SCCOLROW>(nSize), bSkipStartBoundary);
 177 }
 178
 179 // ============================================================================
 180
 181 ScFlatBoolColSegments::ScFlatBoolColSegments() :
 182     mpImpl(new ScFlatBoolSegmentsImpl(static_cast<SCCOLROW>(MAXCOL)))
 183 {
 184 }
 185
 186 ScFlatBoolColSegments::~ScFlatBoolColSegments()
 187 {
 188 }
 189
 190 void ScFlatBoolColSegments::setTrue(SCCOL nCol1, SCCOL nCol2)
 191 {
 192     mpImpl->setTrue(static_cast<SCCOLROW>(nCol1), static_cast<SCCOLROW>(nCol2));
 193 }
 194
 195 void ScFlatBoolColSegments::setFalse(SCCOL nCol1, SCCOL nCol2)
 196 {
 197     mpImpl->setFalse(static_cast<SCCOLROW>(nCol1), static_cast<SCCOLROW>(nCol2));
 198 }
 199
 200 bool ScFlatBoolColSegments::getValue(SCCOL nCol)
 201 {
 202     return mpImpl->getValue(static_cast<SCCOLROW>(nCol));
 203 }
 204
 205 bool ScFlatBoolColSegments::getRangeData(SCCOL nCol, RangeData& rData)
 206 {
 207     ScFlatBoolSegmentsImpl::RangeData aData;
 208     if (!mpImpl->getRangeData(static_cast<SCCOLROW>(nCol), aData))
 209         return false;
 210
 211     rData.mbValue = aData.mbValue;
 212     rData.mnCol1  = static_cast<SCCOL>(aData.mnPos1);
 213     rData.mnCol2  = static_cast<SCCOL>(aData.mnPos2);
 214     return true;
 215 }
 216
 217 void ScFlatBoolColSegments::removeSegment(SCCOL nCol1, SCCOL nCol2)
 218 {
 219     mpImpl->removeSegment(static_cast<SCCOLROW>(nCol1), static_cast<SCCOLROW>(nCol2));
 220 }
 221
 222 void ScFlatBoolColSegments::insertSegment(SCCOL nCol, SCCOL nSize, bool bSkipStartBoundary)
 223 {
 224     mpImpl->insertSegment(static_cast<SCCOLROW>(nCol), static_cast<SCCOLROW>(nSize), bSkipStartBoundary);
 225 }