bridges/source/remote/urp/urp_cache.hxx

   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: urp_cache.hxx,v $
  10  * $Revision: 1.7 $
  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 #include <stdio.h>
  31 #include <list>
  32 #include <algorithm>
  33 #include <rtl/ustring.hxx>
  34
  35 #include "urp_threadid.hxx"
  36 #include "urp_cache.h"
  37
  38 namespace bridges_urp
  39 {
  40
  41     template < class t , class tequals >
  42     inline Cache< t , tequals >::Cache( sal_uInt16 nMaxEntries  ) :
  43         m_pCache( new t[nMaxEntries] ),
  44         m_nMaxEntries( nMaxEntries ),
  45         m_nEntries( 0 )
  46     {
  47
  48     }
  49
  50     template < class t , class tequals >
  51     inline Cache< t , tequals >::~Cache( )
  52     {
  53         delete [] m_pCache;
  54     }
  55
  56
  57     template < class t , class tequals >
  58     inline sal_uInt16 Cache< t , tequals >::put( const t & value )
  59     {
  60         if( ! m_nMaxEntries )
  61         {
  62             return 0xffff;
  63         }
  64         sal_uInt16 nEntry = 0xffff;
  65         if( m_nEntries < m_nMaxEntries )
  66         {
  67             // cache has still empty places
  68             m_pCache[m_nEntries] = value;
  69             nEntry = m_nEntries;
  70             m_nEntries ++;
  71
  72             // add it to the cache
  73             m_lstLeastRecentlyUsed.push_front( nEntry );
  74         }
  75         else
  76         {
  77             // cache is full, remove an element and insert the new one
  78             nEntry = m_lstLeastRecentlyUsed.back();
  79             m_lstLeastRecentlyUsed.pop_back();
  80             m_lstLeastRecentlyUsed.push_front( nEntry );
  81
  82             m_pCache[nEntry] = value;
  83         }
  84         return nEntry;
  85     }
  86
  87     template < class t , class tequals >
  88     inline sal_uInt16 Cache< t , tequals >::seek( const t & value )
  89     {
  90         for( ::std::list< sal_uInt16 >::iterator ii = m_lstLeastRecentlyUsed.begin() ;
  91              ii != m_lstLeastRecentlyUsed.end() ;
  92              ++ ii )
  93         {
  94             if( value == m_pCache[*ii] )
  95             {
  96                 sal_uInt16 nEntry = *ii;
  97                 m_lstLeastRecentlyUsed.erase( ii );
  98                 m_lstLeastRecentlyUsed.push_front( nEntry );
  99                 return nEntry;
 100             }
 101         }
 102         return 0xffff;
 103     }
 104
 105     // helper predicate for element removal
 106     template < class t >
 107     struct PredicateOverMax
 108     {
 109         t m_;
 110         inline PredicateOverMax( const t &value ) : m_(value)
 111             {}
 112         sal_Int32 operator () ( const t &value  )  const
 113             { return value >= m_; }
 114     };
 115
 116     template < class t, class tequals >
 117     inline void Cache < t , tequals >::resize( sal_uInt16 nNewMaxEntries )
 118     {
 119         if( 0 == nNewMaxEntries )
 120         {
 121             m_lstLeastRecentlyUsed.clear();
 122             delete [] m_pCache;
 123             m_pCache = 0;
 124             m_nMaxEntries = 0;
 125         }
 126         else
 127         {
 128             // allocate
 129             t *pNew = new t[nNewMaxEntries];
 130             sal_Int32 nMin = nNewMaxEntries < m_nMaxEntries ? nNewMaxEntries : m_nMaxEntries;
 131
 132             // copy
 133             for( sal_Int32 i = 0; i < nMin ; i ++ )
 134             {
 135                 pNew[i] = m_pCache[i];
 136             }
 137             // delete
 138             delete [] m_pCache;
 139
 140             // assign
 141             m_pCache = pNew;
 142
 143             // remove overlapping lru cache entries
 144             ::std::remove_if(m_lstLeastRecentlyUsed.begin(),
 145                              m_lstLeastRecentlyUsed.end(),
 146                              PredicateOverMax< sal_Int32 > ( nMin ) );
 147         }
 148         m_nMaxEntries = nNewMaxEntries;
 149         m_nEntries = m_nEntries < m_nMaxEntries ?
 150                      m_nEntries : m_nMaxEntries;
 151     }
 152
 153     template < class t, class tequals >
 154     inline void Cache < t, tequals >:: clear()
 155     {
 156         for( sal_Int32 i = 0; i < m_nMaxEntries ; i ++ )
 157         {
 158             m_pCache[i] = t();
 159         }
 160         m_lstLeastRecentlyUsed.clear();
 161         m_nEntries = 0;
 162     }
 163 }