sc/inc/lookupcache.hxx

   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 #ifndef INCLUDED_SC_INC_LOOKUPCACHE_HXX
  21 #define INCLUDED_SC_INC_LOOKUPCACHE_HXX
  22
  23 #include "address.hxx"
  24 #include "global.hxx"
  25 #include <formula/token.hxx>
  26 #include <svl/listener.hxx>
  27
  28 #include <unordered_map>
  29
  30 class ScDocument;
  31 struct ScQueryEntry;
  32
  33 /** Lookup cache for one range used with interpreter functions such as VLOOKUP
  34     and MATCH. Caches query for a specific row and the resulting address looked
  35     up, in case other lookups of the same query in the same row are to be
  36     performed, which usually occur to obtain a different offset column of the
  37     same query.
  38  */
  39
  40 class ScLookupCache : public SvtListener
  41 {
  42 public:
  43
  44     enum Result
  45     {
  46         NOT_CACHED,         /// Query not found in cache.
  47         CRITERIA_DIFFERENT, /// Different criteria for same query position exists.
  48         NOT_AVAILABLE,      /// Criteria not available in lookup range.
  49         FOUND               /// Criteria found.
  50     };
  51
  52     enum QueryOp
  53     {
  54         UNKNOWN,
  55         EQUAL,
  56         LESS_EQUAL,
  57         GREATER_EQUAL
  58     };
  59
  60     class QueryCriteria
  61     {
  62         union
  63         {
  64             double          mfVal;
  65             const OUString *mpStr;
  66         };
  67         bool                mbAlloc;
  68         bool                mbString;
  69         QueryOp             meOp;
  70
  71         void deleteString()
  72         {
  73             if (mbAlloc && mbString)
  74                 delete mpStr;
  75         }
  76
  77         QueryCriteria & operator=( const QueryCriteria & r ) = delete;
  78
  79     public:
  80
  81         explicit QueryCriteria( const ScQueryEntry & rEntry );
  82         QueryCriteria( const QueryCriteria & r );
  83         ~QueryCriteria();
  84
  85         QueryOp getQueryOp() const { return meOp; }
  86
  87         void setDouble( double fVal )
  88         {
  89             deleteString();
  90             mbAlloc = mbString = false;
  91             mfVal = fVal;
  92         }
  93
  94         void setString( const OUString & rStr )
  95         {
  96             deleteString();
  97             mbAlloc = mbString = true;
  98             mpStr = new OUString( rStr);
  99         }
 100
 101         bool operator==( const QueryCriteria & r ) const
 102         {
 103             return meOp == r.meOp && mbString == r.mbString &&
 104                 (mbString ? (*mpStr == *r.mpStr) : (mfVal == r.mfVal));
 105         }
 106
 107     };
 108
 109     /// MUST be new'd because Notify() deletes.
 110                             ScLookupCache( ScDocument * pDoc, const ScRange & rRange );
 111     virtual                 ~ScLookupCache() override;
 112     /// Remove from document structure and delete (!) cache on modify hint.
 113     virtual void Notify( const SfxHint& rHint ) override;
 114
 115     /// @returns document address in o_rAddress if Result==FOUND
 116             Result          lookup( ScAddress & o_rResultAddress,
 117                                     const QueryCriteria & rCriteria,
 118                                     const ScAddress & rQueryAddress ) const;
 119
 120     /** Insert query and result.
 121         @param bAvailable
 122             Pass sal_False if the search didn't deliver a result. A subsequent
 123             lookup() then will return Result::NOT_AVAILABLE.
 124         @returns successful insertion.
 125       */
 126             bool            insert( const ScAddress & rResultAddress,
 127                                     const QueryCriteria & rCriteria,
 128                                     const ScAddress & rQueryAddress,
 129                                     const bool bAvailable );
 130
 131     inline  const ScRange&  getRange() const { return maRange; }
 132
 133     struct Hash
 134     {
 135         size_t operator()( const ScRange & rRange ) const
 136         {
 137             // Lookups are performed on the first column.
 138             return rRange.hashStartColumn();
 139         }
 140     };
 141
 142 private:
 143
 144     struct QueryKey
 145     {
 146         SCROW           mnRow;
 147         SCTAB           mnTab;
 148         QueryOp         meOp;
 149
 150         QueryKey( const ScAddress & rAddress, const QueryOp eOp ) :
 151             mnRow( rAddress.Row()),
 152             mnTab( rAddress.Tab()),
 153             meOp( eOp)
 154         {
 155         }
 156
 157         bool operator==( const QueryKey & r ) const
 158         {
 159             return mnRow == r.mnRow && mnTab == r.mnTab && meOp == r.meOp && meOp != UNKNOWN;
 160         }
 161
 162         struct Hash
 163         {
 164             size_t operator()( const QueryKey & r ) const
 165             {
 166                 return (static_cast<size_t>(r.mnTab) << 24) ^
 167                     (static_cast<size_t>(r.meOp) << 22) ^
 168                     static_cast<size_t>(r.mnRow);
 169             }
 170         };
 171     };
 172
 173     struct QueryCriteriaAndResult
 174     {
 175         QueryCriteria   maCriteria;
 176         ScAddress       maAddress;
 177
 178         QueryCriteriaAndResult( const QueryCriteria & rCriteria, const ScAddress & rAddress ) :
 179             maCriteria( rCriteria),
 180             maAddress( rAddress)
 181         {
 182         }
 183         ~QueryCriteriaAndResult()
 184         {
 185         }
 186     };
 187
 188     typedef std::unordered_map< QueryKey, QueryCriteriaAndResult, QueryKey::Hash > QueryMap;
 189     QueryMap        maQueryMap;
 190     ScRange         maRange;
 191     ScDocument *    mpDoc;
 192
 193     ScLookupCache( const ScLookupCache & ) = delete;
 194     ScLookupCache & operator=( const ScLookupCache & ) = delete;
 195
 196 };
 197
 198 typedef std::unordered_map< ScRange, ScLookupCache*, ScLookupCache::Hash > ScLookupCacheMap;
 199
 200 #endif
 201
 202 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */