sd/source/ui/slidesorter/cache/SlsRequestQueue.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: SlsRequestQueue.cxx,v $
  10  *
  11  * $Revision: 1.5 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "precompiled_sd.hxx"
  35
  36 #include "SlsRequestQueue.hxx"
  37
  38 #include <set>
  39
  40
  41 #undef VERBOSE
  42 //#define VERBOSE
  43
  44 namespace sd { namespace slidesorter { namespace cache {
  45
  46 /** This class extends the actual request data with additional information
  47     that is used by the priority queues.
  48 */
  49 class Request
  50 {
  51 public:
  52     Request (
  53         CacheKey aKey, sal_Int32 nPriority, RequestPriorityClass eClass)
  54         : maKey(aKey), mnPriorityInClass(nPriority), meClass(eClass)
  55     {}
  56     /** Sort requests according to priority classes and then to priorities.
  57     */
  58     class Comparator { public:
  59         bool operator() (const Request& rRequest1, const Request& rRequest2)
  60         {
  61             if (rRequest1.meClass == rRequest2.meClass)
  62                 return (rRequest1.mnPriorityInClass > rRequest2.mnPriorityInClass);
  63             else
  64                 return (rRequest1.meClass < rRequest2.meClass);
  65         }
  66     };
  67     /** Request data is compared arbitrarily by their addresses in memory.
  68         This just establishes an order so that the STL containers are happy.
  69         The order is not semantically interpreted.
  70     */
  71     class DataComparator { public:
  72         DataComparator (const Request&rRequest):maKey(rRequest.maKey){}
  73         DataComparator (const CacheKey aKey):maKey(aKey){}
  74         bool operator() (const Request& rRequest) { return maKey == rRequest.maKey; }
  75     private: const CacheKey maKey;
  76     };
  77
  78     CacheKey maKey;
  79     sal_Int32 mnPriorityInClass;
  80     RequestPriorityClass meClass;
  81 };
  82
  83
  84 class RequestQueue::Container
  85     : public ::std::set<
  86         Request,
  87         Request::Comparator>
  88 {
  89 };
  90
  91
  92
  93
  94 //=====  GenericRequestQueue  =================================================
  95
  96
  97 RequestQueue::RequestQueue (const SharedCacheContext& rpCacheContext)
  98     : maMutex(),
  99       mpRequestQueue(new Container()),
 100       mpCacheContext(rpCacheContext),
 101       mnMinimumPriority(0),
 102       mnMaximumPriority(1)
 103 {
 104 }
 105
 106
 107
 108
 109 RequestQueue::~RequestQueue (void)
 110 {
 111 }
 112
 113
 114
 115
 116 void RequestQueue::AddRequest (
 117     CacheKey aKey,
 118     RequestPriorityClass eRequestClass,
 119     bool /*bInsertWithHighestPriority*/)
 120 {
 121     ::osl::MutexGuard aGuard (maMutex);
 122
 123     OSL_ASSERT(eRequestClass>=MIN__CLASS && eRequestClass<=MAX__CLASS);
 124
 125     // If the request is already a member of the queue then remove it so
 126     // that the following insertion will use the new prioritization.
 127 #ifdef VERBOSE
 128     bool bRemoved =
 129 #endif
 130         RemoveRequest(aKey);
 131
 132     // The priority of the request inside its priority class is defined by
 133     // the page number.  This ensures a strict top-to-bottom, left-to-right
 134     // order.
 135     sal_Int32 nPriority (mpCacheContext->GetPriority(aKey));
 136     Request aRequest (aKey, nPriority, eRequestClass);
 137     mpRequestQueue->insert(aRequest);
 138
 139     SSCD_SET_REQUEST_CLASS(rRequestData.GetPage(),eRequestClass);
 140
 141 #ifdef VERBOSE
 142     OSL_TRACE("%s request for page %d with priority class %d",
 143         bRemoved?"replaced":"added",
 144         (rRequestData.GetPage()->GetPageNum()-1)/2,
 145         eRequestClass);
 146 #endif
 147 }
 148
 149
 150
 151
 152 bool RequestQueue::RemoveRequest (
 153     CacheKey aKey)
 154 {
 155     bool bRequestWasRemoved (false);
 156     ::osl::MutexGuard aGuard (maMutex);
 157
 158     while(true)
 159     {
 160         Container::const_iterator aRequestIterator = ::std::find_if (
 161             mpRequestQueue->begin(),
 162             mpRequestQueue->end(),
 163             Request::DataComparator(aKey));
 164         if (aRequestIterator != mpRequestQueue->end())
 165         {
 166             if (aRequestIterator->mnPriorityInClass == mnMinimumPriority+1)
 167                 mnMinimumPriority++;
 168             else if (aRequestIterator->mnPriorityInClass == mnMaximumPriority-1)
 169                 mnMaximumPriority--;
 170             mpRequestQueue->erase(aRequestIterator);
 171             bRequestWasRemoved = true;
 172
 173             if (bRequestWasRemoved)
 174             {
 175                 SSCD_SET_STATUS(rRequest.GetPage(),NONE);
 176             }
 177         }
 178         else
 179             break;
 180     }
 181
 182     return bRequestWasRemoved;
 183 }
 184
 185
 186
 187
 188 void RequestQueue::ChangeClass (
 189     CacheKey aKey,
 190     RequestPriorityClass eNewRequestClass)
 191 {
 192     ::osl::MutexGuard aGuard (maMutex);
 193
 194     OSL_ASSERT(eNewRequestClass>=MIN__CLASS && eNewRequestClass<=MAX__CLASS);
 195
 196     Container::const_iterator iRequest (
 197         ::std::find_if (
 198             mpRequestQueue->begin(),
 199             mpRequestQueue->end(),
 200             Request::DataComparator(aKey)));
 201     if (iRequest!=mpRequestQueue->end() && iRequest->meClass!=eNewRequestClass)
 202     {
 203         AddRequest(aKey, eNewRequestClass, true);
 204         SSCD_SET_REQUEST_CLASS(rRequestData.GetPage(),eNewRequestClass);
 205     }
 206 }
 207
 208
 209
 210
 211 CacheKey RequestQueue::GetFront (void)
 212 {
 213     ::osl::MutexGuard aGuard (maMutex);
 214
 215     if (mpRequestQueue->empty())
 216         throw ::com::sun::star::uno::RuntimeException(
 217             ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 218                 "RequestQueue::GetFront(): queue is empty")),
 219             NULL);
 220
 221     return mpRequestQueue->begin()->maKey;
 222 }
 223
 224
 225
 226
 227 RequestPriorityClass RequestQueue::GetFrontPriorityClass (void)
 228 {
 229     ::osl::MutexGuard aGuard (maMutex);
 230
 231     if (mpRequestQueue->empty())
 232         throw ::com::sun::star::uno::RuntimeException(
 233             ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 234                 "RequestQueue::GetFrontPriorityClass(): queue is empty")),
 235             NULL);
 236
 237     return mpRequestQueue->begin()->meClass;
 238 }
 239
 240
 241
 242
 243 void RequestQueue::PopFront (void)
 244 {
 245     ::osl::MutexGuard aGuard (maMutex);
 246
 247     if ( ! mpRequestQueue->empty())
 248     {
 249         SSCD_SET_STATUS(maRequestQueue.begin()->mpData->GetPage(),NONE);
 250
 251         mpRequestQueue->erase(mpRequestQueue->begin());
 252
 253         // Reset the priority counter if possible.
 254         if (mpRequestQueue->empty())
 255         {
 256             mnMinimumPriority = 0;
 257             mnMaximumPriority = 1;
 258         }
 259     }
 260 }
 261
 262
 263
 264
 265 bool RequestQueue::IsEmpty (void)
 266 {
 267     ::osl::MutexGuard aGuard (maMutex);
 268     return mpRequestQueue->empty();
 269 }
 270
 271
 272
 273
 274 void RequestQueue::Clear (void)
 275 {
 276     ::osl::MutexGuard aGuard (maMutex);
 277
 278     mpRequestQueue->clear();
 279     mnMinimumPriority = 0;
 280     mnMaximumPriority = 1;
 281 }
 282
 283
 284
 285
 286 ::osl::Mutex& RequestQueue::GetMutex (void)
 287 {
 288     return maMutex;
 289 }
 290
 291
 292 } } } // end of namespace ::sd::slidesorter::cache
 293
 294
 295