sc/source/core/data/sortparam.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 "sortparam.hxx"
  21 #include "global.hxx"
  22 #include "address.hxx"
  23 #include "queryparam.hxx"
  24 #include "subtotalparam.hxx"
  25
  26 #include <osl/diagnose.h>
  27
  28 ScSortParam::ScSortParam()
  29 {
  30     Clear();
  31 }
  32
  33 ScSortParam::ScSortParam( const ScSortParam& r ) :
  34         nCol1(r.nCol1),nRow1(r.nRow1),nCol2(r.nCol2),nRow2(r.nRow2),nUserIndex(r.nUserIndex),
  35         bHasHeader(r.bHasHeader),bByRow(r.bByRow),bCaseSens(r.bCaseSens),
  36         bNaturalSort(r.bNaturalSort),bUserDef(r.bUserDef),
  37         bIncludePattern(r.bIncludePattern),bInplace(r.bInplace),
  38         nDestTab(r.nDestTab),nDestCol(r.nDestCol),nDestRow(r.nDestRow),
  39         maKeyState( r.maKeyState ),
  40         aCollatorLocale( r.aCollatorLocale ), aCollatorAlgorithm( r.aCollatorAlgorithm ),
  41         nCompatHeader( r.nCompatHeader )
  42 {
  43 }
  44
  45 ScSortParam::~ScSortParam() {}
  46
  47 void ScSortParam::Clear()
  48 {
  49     ScSortKeyState aKeyState;
  50
  51     nCol1=nCol2=nDestCol = 0;
  52     nRow1=nRow2=nDestRow = 0;
  53     nCompatHeader = 2;
  54     nDestTab = 0;
  55     nUserIndex = 0;
  56     bHasHeader=bCaseSens=bUserDef=bNaturalSort = false;
  57     bByRow=bIncludePattern=bInplace = true;
  58     aCollatorLocale = ::com::sun::star::lang::Locale();
  59     aCollatorAlgorithm.clear();
  60
  61     aKeyState.bDoSort = false;
  62     aKeyState.nField = 0;
  63     aKeyState.bAscending = true;
  64
  65     // Initialize to default size
  66     maKeyState.assign( DEFSORT, aKeyState );
  67 }
  68
  69 ScSortParam& ScSortParam::operator=( const ScSortParam& r )
  70 {
  71     nCol1           = r.nCol1;
  72     nRow1           = r.nRow1;
  73     nCol2           = r.nCol2;
  74     nRow2           = r.nRow2;
  75     nUserIndex      = r.nUserIndex;
  76     bHasHeader      = r.bHasHeader;
  77     bByRow          = r.bByRow;
  78     bCaseSens       = r.bCaseSens;
  79     bNaturalSort    = r.bNaturalSort;
  80     bUserDef        = r.bUserDef;
  81     bIncludePattern = r.bIncludePattern;
  82     bInplace        = r.bInplace;
  83     nDestTab        = r.nDestTab;
  84     nDestCol        = r.nDestCol;
  85     nDestRow        = r.nDestRow;
  86     maKeyState      = r.maKeyState;
  87     aCollatorLocale         = r.aCollatorLocale;
  88     aCollatorAlgorithm      = r.aCollatorAlgorithm;
  89     nCompatHeader   = r.nCompatHeader;
  90
  91     return *this;
  92 }
  93
  94 bool ScSortParam::operator==( const ScSortParam& rOther ) const
  95 {
  96     bool bEqual = false;
  97     // Number of Sorts the same?
  98     sal_uInt16 nLast      = 0;
  99     sal_uInt16 nOtherLast = 0;
 100     sal_uInt16 nSortSize = GetSortKeyCount();
 101
 102     if ( !maKeyState.empty() )
 103     {
 104         while ( maKeyState[nLast++].bDoSort && nLast < nSortSize ) ;
 105         nLast--;
 106     }
 107
 108     if ( !rOther.maKeyState.empty() )
 109     {
 110         while ( rOther.maKeyState[nOtherLast++].bDoSort && nOtherLast < nSortSize ) ;
 111         nOtherLast--;
 112     }
 113
 114     if (   (nLast           == nOtherLast)
 115         && (nCol1           == rOther.nCol1)
 116         && (nRow1           == rOther.nRow1)
 117         && (nCol2           == rOther.nCol2)
 118         && (nRow2           == rOther.nRow2)
 119         && (bHasHeader      == rOther.bHasHeader)
 120         && (bByRow          == rOther.bByRow)
 121         && (bCaseSens       == rOther.bCaseSens)
 122         && (bNaturalSort    == rOther.bNaturalSort)
 123         && (bUserDef        == rOther.bUserDef)
 124         && (nUserIndex      == rOther.nUserIndex)
 125         && (bIncludePattern == rOther.bIncludePattern)
 126         && (bInplace        == rOther.bInplace)
 127         && (nDestTab        == rOther.nDestTab)
 128         && (nDestCol        == rOther.nDestCol)
 129         && (nDestRow        == rOther.nDestRow)
 130         && (aCollatorLocale.Language    == rOther.aCollatorLocale.Language)
 131         && (aCollatorLocale.Country     == rOther.aCollatorLocale.Country)
 132         && (aCollatorLocale.Variant     == rOther.aCollatorLocale.Variant)
 133         && (aCollatorAlgorithm          == rOther.aCollatorAlgorithm)
 134         && ( !maKeyState.empty() || !rOther.maKeyState.empty() )
 135         )
 136     {
 137         bEqual = true;
 138         for ( sal_uInt16 i=0; i<=nLast && bEqual; i++ )
 139             bEqual = ( maKeyState[i].nField == rOther.maKeyState[i].nField ) &&
 140                 ( maKeyState[i].bAscending  == rOther.maKeyState[i].bAscending );
 141     }
 142     if ( maKeyState.empty() && rOther.maKeyState.empty() )
 143         bEqual = true;
 144
 145     return bEqual;
 146 }
 147
 148 ScSortParam::ScSortParam( const ScSubTotalParam& rSub, const ScSortParam& rOld ) :
 149         nCol1(rSub.nCol1),nRow1(rSub.nRow1),nCol2(rSub.nCol2),nRow2(rSub.nRow2),nUserIndex(rSub.nUserIndex),
 150         bHasHeader(true),bByRow(true),bCaseSens(rSub.bCaseSens),bNaturalSort(rOld.bNaturalSort),
 151         bUserDef(rSub.bUserDef),bIncludePattern(rSub.bIncludePattern),
 152         bInplace(true),
 153         nDestTab(0),nDestCol(0),nDestRow(0),
 154         aCollatorLocale( rOld.aCollatorLocale ), aCollatorAlgorithm( rOld.aCollatorAlgorithm ),
 155         nCompatHeader( rOld.nCompatHeader )
 156 {
 157     sal_uInt16 i;
 158
 159     //  first the groups from the partial results
 160     if (rSub.bDoSort)
 161         for (i=0; i<MAXSUBTOTAL; i++)
 162             if (rSub.bGroupActive[i])
 163             {
 164                 ScSortKeyState key;
 165                 key.bDoSort = true;
 166                 key.nField = rSub.nField[i];
 167                 key.bAscending = rSub.bAscending;
 168                 maKeyState.push_back(key);
 169             }
 170
 171     //  then the old settings
 172     for (i=0; i < rOld.GetSortKeyCount(); i++)
 173         if (rOld.maKeyState[i].bDoSort)
 174         {
 175             SCCOLROW nThisField = rOld.maKeyState[i].nField;
 176             bool bDouble = false;
 177             for (sal_uInt16 j = 0; j < GetSortKeyCount(); j++)
 178                 if ( maKeyState[j].nField == nThisField )
 179                     bDouble = true;
 180             if (!bDouble)               // do not enter a field twice
 181             {
 182                 ScSortKeyState key;
 183                 key.bDoSort = true;
 184                 key.nField = nThisField;
 185                 key.bAscending = rOld.maKeyState[i].bAscending;
 186                 maKeyState.push_back(key);
 187             }
 188         }
 189 }
 190
 191 ScSortParam::ScSortParam( const ScQueryParam& rParam, SCCOL nCol ) :
 192         nCol1(nCol),nRow1(rParam.nRow1),nCol2(nCol),nRow2(rParam.nRow2),nUserIndex(0),
 193         bHasHeader(rParam.bHasHeader),bByRow(true),bCaseSens(rParam.bCaseSens),
 194         bNaturalSort(false),
 195 //TODO: what about Locale and Algorithm?
 196         bUserDef(false),bIncludePattern(false),
 197         bInplace(true),
 198         nDestTab(0),nDestCol(0),nDestRow(0), nCompatHeader(2)
 199 {
 200     ScSortKeyState aKeyState;
 201     aKeyState.bDoSort = true;
 202     aKeyState.nField = nCol;
 203     aKeyState.bAscending = true;
 204
 205     maKeyState.push_back( aKeyState );
 206
 207     // Set the rest
 208     aKeyState.bDoSort = false;
 209     aKeyState.nField = 0;
 210
 211     for (sal_uInt16 i=1; i<GetSortKeyCount(); i++)
 212         maKeyState.push_back( aKeyState );
 213 }
 214
 215 void ScSortParam::MoveToDest()
 216 {
 217     if (!bInplace)
 218     {
 219         SCsCOL nDifX = ((SCsCOL) nDestCol) - ((SCsCOL) nCol1);
 220         SCsROW nDifY = ((SCsROW) nDestRow) - ((SCsROW) nRow1);
 221
 222         nCol1 = sal::static_int_cast<SCCOL>( nCol1 + nDifX );
 223         nRow1 = sal::static_int_cast<SCROW>( nRow1 + nDifY );
 224         nCol2 = sal::static_int_cast<SCCOL>( nCol2 + nDifX );
 225         nRow2 = sal::static_int_cast<SCROW>( nRow2 + nDifY );
 226         for (sal_uInt16 i=0; i<GetSortKeyCount(); i++)
 227             if (bByRow)
 228                 maKeyState[i].nField += nDifX;
 229             else
 230                 maKeyState[i].nField += nDifY;
 231
 232         bInplace = true;
 233     }
 234     else
 235     {
 236         OSL_FAIL("MoveToDest, bInplace == TRUE");
 237     }
 238 }
 239
 240 namespace sc {
 241
 242 namespace {
 243
 244 struct ReorderIndex
 245 {
 246     struct LessByPos2 : std::binary_function<ReorderIndex, ReorderIndex, bool>
 247     {
 248         bool operator() ( const ReorderIndex& r1, const ReorderIndex& r2 ) const
 249         {
 250             return r1.mnPos2 < r2.mnPos2;
 251         }
 252     };
 253
 254     SCCOLROW mnPos1;
 255     SCCOLROW mnPos2;
 256
 257     ReorderIndex( SCCOLROW nPos1, SCCOLROW nPos2 ) : mnPos1(nPos1), mnPos2(nPos2) {}
 258 };
 259
 260 }
 261
 262 void ReorderParam::reverse()
 263 {
 264     SCCOLROW nStart;
 265     if (mbByRow)
 266         nStart = maSortRange.aStart.Row();
 267     else
 268         nStart = maSortRange.aStart.Col();
 269
 270     size_t n = maOrderIndices.size();
 271     std::vector<ReorderIndex> aBucket;
 272     aBucket.reserve(n);
 273     for (size_t i = 0; i < n; ++i)
 274     {
 275         SCCOLROW nPos1 = i + nStart;
 276         SCCOLROW nPos2 = maOrderIndices[i];
 277         aBucket.push_back(ReorderIndex(nPos1, nPos2));
 278     }
 279
 280     std::sort(aBucket.begin(), aBucket.end(), ReorderIndex::LessByPos2());
 281     std::vector<SCCOLROW> aNew;
 282     aNew.reserve(n);
 283     for (size_t i = 0; i < n; ++i)
 284         aNew.push_back(aBucket[i].mnPos1);
 285
 286     maOrderIndices.swap(aNew);
 287 }
 288
 289 }
 290
 291 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */