boost->std

Change-Id: I1e6a7fd66f90e6acd803c6cd464f1d73252f7bcb

15 files changed, 66 insertions, 68 deletions

diff --git a/sd/source/ui/slidesorter/cache/SlsBitmapCache.cxx b/sd/source/ui/slidesorter/cache/SlsBitmapCache.cxx
index eabd8aeb0176..46a3fca292af 100644
--- a/sd/source/ui/slidesorter/cache/SlsBitmapCache.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsBitmapCache.cxx
@@ -43,7 +43,7 @@ public:
     ~CacheEntry() {};
     inline void Recycle (const CacheEntry& rEntry);
     inline sal_Int32 GetMemorySize() const;
-    void Compress (const ::boost::shared_ptr<BitmapCompressor>& rpCompressor);
+    void Compress (const std::shared_ptr<BitmapCompressor>& rpCompressor);
     inline void Decompress();
 
     bool IsUpToDate() const { return mbIsUpToDate; }
@@ -67,8 +67,8 @@ public:
 private:
     Bitmap maPreview;
     Bitmap maMarkedPreview;
-    ::boost::shared_ptr<BitmapReplacement> mpReplacement;
-    ::boost::shared_ptr<BitmapCompressor> mpCompressor;
+    std::shared_ptr<BitmapReplacement> mpReplacement;
+    std::shared_ptr<BitmapCompressor> mpCompressor;
     Size maBitmapSize;
     bool mbIsUpToDate;
     sal_Int32 mnLastAccessTime;
@@ -414,7 +414,7 @@ void BitmapCache::Recycle (const BitmapCache& rCache)
 
 void BitmapCache::Compress (
     const CacheKey& rKey,
-    const ::boost::shared_ptr<BitmapCompressor>& rpCompressor)
+    const std::shared_ptr<BitmapCompressor>& rpCompressor)
 {
     ::osl::MutexGuard aGuard (maMutex);
 
@@ -504,7 +504,7 @@ inline sal_Int32 BitmapCache::CacheEntry::GetMemorySize() const
     return nSize;
 }
 
-void BitmapCache::CacheEntry::Compress (const ::boost::shared_ptr<BitmapCompressor>& rpCompressor)
+void BitmapCache::CacheEntry::Compress (const std::shared_ptr<BitmapCompressor>& rpCompressor)
 {
     if ( ! maPreview.IsEmpty())
     {
diff --git a/sd/source/ui/slidesorter/cache/SlsBitmapCache.hxx b/sd/source/ui/slidesorter/cache/SlsBitmapCache.hxx
index fe022d4ace48..29390abb943f 100644
--- a/sd/source/ui/slidesorter/cache/SlsBitmapCache.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsBitmapCache.hxx
@@ -24,8 +24,7 @@ class SdrPage;
 
 #include <vcl/bitmapex.hxx>
 #include <osl/mutex.hxx>
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 namespace sd { namespace slidesorter { namespace cache {
 
@@ -170,12 +169,12 @@ public:
     */
     void Compress (
         const CacheKey& rKey,
-        const ::boost::shared_ptr<BitmapCompressor>& rpCompressor);
+        const std::shared_ptr<BitmapCompressor>& rpCompressor);
 
 private:
     mutable ::osl::Mutex maMutex;
 
-    ::boost::scoped_ptr<CacheBitmapContainer> mpBitmapContainer;
+    std::unique_ptr<CacheBitmapContainer> mpBitmapContainer;
 
     /** Total size of bytes that are occupied by bitmaps in the cache for
         whom the slides are currently not inside the visible area.
diff --git a/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.cxx b/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.cxx
index d1e222214d4d..da99597c9f61 100644
--- a/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.cxx
@@ -43,9 +43,9 @@ public:
     virtual sal_Int32 GetMemorySize() const SAL_OVERRIDE { return maPreview.GetSizeBytes(); }
 };
 
-::boost::shared_ptr<BitmapReplacement> NoBitmapCompression::Compress (const Bitmap& rBitmap) const
+std::shared_ptr<BitmapReplacement> NoBitmapCompression::Compress (const Bitmap& rBitmap) const
 {
-    return ::boost::shared_ptr<BitmapReplacement>(new DummyReplacement(rBitmap));
+    return std::shared_ptr<BitmapReplacement>(new DummyReplacement(rBitmap));
 }
 
 Bitmap NoBitmapCompression::Decompress (const BitmapReplacement& rBitmapData) const
@@ -60,9 +60,9 @@ bool NoBitmapCompression::IsLossless() const
 
 //===== CompressionByDeletion =================================================
 
-::boost::shared_ptr<BitmapReplacement> CompressionByDeletion::Compress (const Bitmap& ) const
+std::shared_ptr<BitmapReplacement> CompressionByDeletion::Compress (const Bitmap& ) const
 {
-    return ::boost::shared_ptr<BitmapReplacement>();
+    return std::shared_ptr<BitmapReplacement>();
 }
 
 Bitmap CompressionByDeletion::Decompress (const BitmapReplacement& ) const
@@ -100,7 +100,7 @@ sal_Int32 ResolutionReduction::ResolutionReducedReplacement::GetMemorySize() con
     return maPreview.GetSizeBytes();
 }
 
-::boost::shared_ptr<BitmapReplacement> ResolutionReduction::Compress (
+std::shared_ptr<BitmapReplacement> ResolutionReduction::Compress (
     const Bitmap& rBitmap) const
 {
     ResolutionReducedReplacement* pResult = new ResolutionReducedReplacement();
@@ -113,7 +113,7 @@ sal_Int32 ResolutionReduction::ResolutionReducedReplacement::GetMemorySize() con
         pResult->maPreview.Scale(Size(mnWidth,nHeight));
     }
 
-    return ::boost::shared_ptr<BitmapReplacement>(pResult);
+    return std::shared_ptr<BitmapReplacement>(pResult);
 }
 
 Bitmap ResolutionReduction::Decompress (const BitmapReplacement& rBitmapData) const
@@ -161,7 +161,7 @@ public:
     }
 };
 
-::boost::shared_ptr<BitmapReplacement> PngCompression::Compress (const Bitmap& rBitmap) const
+std::shared_ptr<BitmapReplacement> PngCompression::Compress (const Bitmap& rBitmap) const
 {
     vcl::PNGWriter aWriter (rBitmap);
     SvMemoryStream aStream (32768, 32768);
@@ -173,7 +173,7 @@ public:
     pResult->mpData = new char[pResult->mnDataSize];
     memcpy(pResult->mpData, aStream.GetData(), pResult->mnDataSize);
 
-    return ::boost::shared_ptr<BitmapReplacement>(pResult);
+    return std::shared_ptr<BitmapReplacement>(pResult);
 }
 
 Bitmap PngCompression::Decompress (
diff --git a/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.hxx b/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.hxx
index 6c40c0d4d4c4..243ebcfbfb90 100644
--- a/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsBitmapCompressor.hxx
@@ -21,7 +21,7 @@
 #define INCLUDED_SD_SOURCE_UI_SLIDESORTER_CACHE_SLSBITMAPCOMPRESSOR_HXX
 
 #include <sal/types.h>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 class Bitmap;
 
@@ -38,7 +38,7 @@ public:
     /** Compress the given bitmap into a replacement format that is specific
         to the compressor class.
     */
-    virtual ::boost::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const = 0;
+    virtual std::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const = 0;
 
     /** Decompress the given replacement data into a preview bitmap.
         Depending on the compression technique the returned bitmap may
@@ -82,7 +82,7 @@ class NoBitmapCompression
     class DummyReplacement;
 public:
     virtual ~NoBitmapCompression() {}
-    virtual ::boost::shared_ptr<BitmapReplacement> Compress (const Bitmap& rpBitmap) const SAL_OVERRIDE;
+    virtual std::shared_ptr<BitmapReplacement> Compress (const Bitmap& rpBitmap) const SAL_OVERRIDE;
     virtual Bitmap Decompress (const BitmapReplacement& rBitmapData) const SAL_OVERRIDE;
     virtual bool IsLossless() const SAL_OVERRIDE;
 };
@@ -97,7 +97,7 @@ class CompressionByDeletion
 {
 public:
     virtual ~CompressionByDeletion() {}
-    virtual ::boost::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const SAL_OVERRIDE;
+    virtual std::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const SAL_OVERRIDE;
     virtual Bitmap Decompress (const BitmapReplacement& rBitmapData) const SAL_OVERRIDE;
     virtual bool IsLossless() const SAL_OVERRIDE;
 };
@@ -114,7 +114,7 @@ class ResolutionReduction
     static const sal_Int32 mnWidth = 100;
 public:
     virtual ~ResolutionReduction() {}
-    virtual ::boost::shared_ptr<BitmapReplacement> Compress (const Bitmap& rpBitmap) const SAL_OVERRIDE;
+    virtual std::shared_ptr<BitmapReplacement> Compress (const Bitmap& rpBitmap) const SAL_OVERRIDE;
     /** Scale the replacement bitmap up to the original size.
     */
     virtual Bitmap Decompress (const BitmapReplacement& rBitmapData) const SAL_OVERRIDE;
@@ -130,7 +130,7 @@ class PngCompression
     class PngReplacement;
 public:
     virtual ~PngCompression() {}
-    virtual ::boost::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const SAL_OVERRIDE;
+    virtual std::shared_ptr<BitmapReplacement> Compress (const Bitmap& rBitmap) const SAL_OVERRIDE;
     virtual Bitmap Decompress (const BitmapReplacement& rBitmapData) const SAL_OVERRIDE;
     virtual bool IsLossless() const SAL_OVERRIDE;
 };
diff --git a/sd/source/ui/slidesorter/cache/SlsBitmapFactory.hxx b/sd/source/ui/slidesorter/cache/SlsBitmapFactory.hxx
index 80805787be51..af4323b64b1b 100644
--- a/sd/source/ui/slidesorter/cache/SlsBitmapFactory.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsBitmapFactory.hxx
@@ -21,7 +21,7 @@
 #define INCLUDED_SD_SOURCE_UI_SLIDESORTER_CACHE_SLSBITMAPFACTORY_HXX
 
 #include "PreviewRenderer.hxx"
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 class SdPage;
 class Size;
diff --git a/sd/source/ui/slidesorter/cache/SlsCacheCompactor.cxx b/sd/source/ui/slidesorter/cache/SlsCacheCompactor.cxx
index ea0dc48d9264..d85a7064cdf7 100644
--- a/sd/source/ui/slidesorter/cache/SlsCacheCompactor.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsCacheCompactor.cxx
@@ -64,13 +64,13 @@ public:
     CacheCompactionByCompression (
         ::sd::slidesorter::cache::BitmapCache& rCache,
         sal_Int32 nMaximalCacheSize,
-        const ::boost::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>& rpCompressor);
+        const std::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>& rpCompressor);
 
 protected:
     virtual void Run() SAL_OVERRIDE;
 
 private:
-    ::boost::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>  mpCompressor;
+    std::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>  mpCompressor;
 };
 
 } // end of anonymous namespace
@@ -87,7 +87,7 @@ namespace sd { namespace slidesorter { namespace cache {
     static const char sResolution[] = "ResolutionReduction";
     static const char sPNGCompression[] = "PNGCompression";
 
-    ::boost::shared_ptr<BitmapCompressor> pCompressor;
+    std::shared_ptr<BitmapCompressor> pCompressor;
     OUString sCompressionPolicy(sPNGCompression);
     Any aCompressionPolicy (CacheConfiguration::Instance()->GetValue("CompressionPolicy"));
     if (aCompressionPolicy.has<OUString>())
@@ -159,7 +159,7 @@ namespace {
 CacheCompactionByCompression::CacheCompactionByCompression (
     ::sd::slidesorter::cache::BitmapCache& rCache,
     sal_Int32 nMaximalCacheSize,
-    const ::boost::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>& rpCompressor)
+    const std::shared_ptr< ::sd::slidesorter::cache::BitmapCompressor>& rpCompressor)
     : CacheCompactor(rCache,nMaximalCacheSize),
       mpCompressor(rpCompressor)
 {
diff --git a/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.cxx b/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.cxx
index cae6b2724504..39ad6efd7962 100644
--- a/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.cxx
@@ -35,15 +35,15 @@ namespace sd { namespace slidesorter { namespace cache {
 
 namespace
 {
-    typedef ::boost::shared_ptr<CacheConfiguration> CacheConfigSharedPtr;
+    typedef std::shared_ptr<CacheConfiguration> CacheConfigSharedPtr;
     class theInstance :
         public rtl::Static<CacheConfigSharedPtr, theInstance> {};
 }
 
-::boost::weak_ptr<CacheConfiguration> CacheConfiguration::mpWeakInstance;
+std::weak_ptr<CacheConfiguration> CacheConfiguration::mpWeakInstance;
 Timer CacheConfiguration::maReleaseTimer;
 
-::boost::shared_ptr<CacheConfiguration> CacheConfiguration::Instance()
+std::shared_ptr<CacheConfiguration> CacheConfiguration::Instance()
 {
     SolarMutexGuard aSolarGuard;
     CacheConfigSharedPtr &rInstancePtr = theInstance::get();
@@ -51,7 +51,7 @@ Timer CacheConfiguration::maReleaseTimer;
     {
         // Maybe somebody else kept a previously created instance alive.
         if ( ! mpWeakInstance.expired())
-            rInstancePtr = ::boost::shared_ptr<CacheConfiguration>(mpWeakInstance);
+            rInstancePtr = std::shared_ptr<CacheConfiguration>(mpWeakInstance);
         if (rInstancePtr.get() == NULL)
         {
             // We have to create a new instance.
diff --git a/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.hxx b/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.hxx
index 2f55a20cae49..606233b38a2e 100644
--- a/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsCacheConfiguration.hxx
@@ -23,8 +23,7 @@
 #include <com/sun/star/uno/Any.hxx>
 #include <vcl/timer.hxx>
 #include <com/sun/star/container/XNameAccess.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
+#include <memory>
 
 namespace sd { namespace slidesorter { namespace cache {
 
@@ -38,7 +37,7 @@ public:
         seconds.  Subsequent calls to this function will create a new
         instance.
     */
-    static ::boost::shared_ptr<CacheConfiguration> Instance();
+    static std::shared_ptr<CacheConfiguration> Instance();
 
     /** Look up the specified value in
         MultiPaneGUI/SlideSorter/PreviewCache.   When the specified value
@@ -50,7 +49,7 @@ private:
     /** When a caller holds a reference after we have released ours we use
         this weak pointer to avoid creating a new instance.
     */
-    static ::boost::weak_ptr<CacheConfiguration> mpWeakInstance;
+    static std::weak_ptr<CacheConfiguration> mpWeakInstance;
     static Timer maReleaseTimer;
     ::com::sun::star::uno::Reference<
         ::com::sun::star::container::XNameAccess> mxCacheNode;
diff --git a/sd/source/ui/slidesorter/cache/SlsGenericPageCache.cxx b/sd/source/ui/slidesorter/cache/SlsGenericPageCache.cxx
index fe4a6dda6116..d2058991eb92 100644
--- a/sd/source/ui/slidesorter/cache/SlsGenericPageCache.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsGenericPageCache.cxx
@@ -214,7 +214,7 @@ void GenericPageCache::RequestPreviewBitmap (
 bool GenericPageCache::InvalidatePreviewBitmap (const CacheKey aKey)
 {
     // Invalidate the page in all caches that reference it, not just this one.
-    ::boost::shared_ptr<cache::PageCacheManager> pCacheManager (
+    std::shared_ptr<cache::PageCacheManager> pCacheManager (
         cache::PageCacheManager::Instance());
     if (pCacheManager)
         return pCacheManager->InvalidatePreviewBitmap(
diff --git a/sd/source/ui/slidesorter/cache/SlsGenericPageCache.hxx b/sd/source/ui/slidesorter/cache/SlsGenericPageCache.hxx
index 207dceeb531e..315b91411b0d 100644
--- a/sd/source/ui/slidesorter/cache/SlsGenericPageCache.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsGenericPageCache.hxx
@@ -22,7 +22,7 @@
 
 #include "SlideSorter.hxx"
 #include "SlsRequestQueue.hxx"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 namespace sd { namespace slidesorter { namespace cache {
 
@@ -128,11 +128,11 @@ public:
     void Resume();
 
 private:
-    ::boost::shared_ptr<BitmapCache> mpBitmapCache;
+    std::shared_ptr<BitmapCache> mpBitmapCache;
 
     RequestQueue maRequestQueue;
 
-    ::boost::scoped_ptr<QueueProcessor> mpQueueProcessor;
+    std::unique_ptr<QueueProcessor> mpQueueProcessor;
 
     SharedCacheContext mpCacheContext;
 
diff --git a/sd/source/ui/slidesorter/cache/SlsPageCacheManager.cxx b/sd/source/ui/slidesorter/cache/SlsPageCacheManager.cxx
index 9e8624bb3add..0e639944a58e 100644
--- a/sd/source/ui/slidesorter/cache/SlsPageCacheManager.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsPageCacheManager.cxx
@@ -25,7 +25,7 @@
 
 #include <deque>
 #include <map>
-#include <boost/weak_ptr.hpp>
+#include <memory>
 
 namespace {
 
@@ -62,12 +62,12 @@ class RecentlyUsedCacheDescriptor
 public:
     ::sd::slidesorter::cache::PageCacheManager::DocumentKey mpDocument;
     Size maPreviewSize;
-    ::boost::shared_ptr< ::sd::slidesorter::cache::PageCacheManager::Cache> mpCache;
+    std::shared_ptr< ::sd::slidesorter::cache::PageCacheManager::Cache> mpCache;
 
     RecentlyUsedCacheDescriptor(
         ::sd::slidesorter::cache::PageCacheManager::DocumentKey pDocument,
         const Size& rPreviewSize,
-        const ::boost::shared_ptr< ::sd::slidesorter::cache::PageCacheManager::Cache>& rpCache)
+        const std::shared_ptr< ::sd::slidesorter::cache::PageCacheManager::Cache>& rpCache)
         :mpDocument(pDocument),maPreviewSize(rPreviewSize),mpCache(rpCache)
     {}
 };
@@ -112,7 +112,7 @@ namespace sd { namespace slidesorter { namespace cache {
 */
 class PageCacheManager::PageCacheContainer
     : public std::unordered_map<CacheDescriptor,
-                             ::boost::shared_ptr<PageCacheManager::Cache>,
+                             std::shared_ptr<PageCacheManager::Cache>,
                              CacheDescriptor::Hash,
                              CacheDescriptor::Equal>
 {
@@ -123,12 +123,12 @@ public:
         address only.
     */
     class CompareWithCache { public:
-        CompareWithCache(const ::boost::shared_ptr<PageCacheManager::Cache>& rpCache)
+        CompareWithCache(const std::shared_ptr<PageCacheManager::Cache>& rpCache)
             : mpCache(rpCache) {}
         bool operator () (const PageCacheContainer::value_type& rValue) const
         { return rValue.second == mpCache; }
     private:
-        ::boost::shared_ptr<PageCacheManager::Cache> mpCache;
+        std::shared_ptr<PageCacheManager::Cache> mpCache;
     };
 };
 
@@ -160,18 +160,18 @@ public:
 
 //===== PageCacheManager ====================================================
 
-::boost::weak_ptr<PageCacheManager> PageCacheManager::mpInstance;
+std::weak_ptr<PageCacheManager> PageCacheManager::mpInstance;
 
-::boost::shared_ptr<PageCacheManager> PageCacheManager::Instance()
+std::shared_ptr<PageCacheManager> PageCacheManager::Instance()
 {
-    ::boost::shared_ptr<PageCacheManager> pInstance;
+    std::shared_ptr<PageCacheManager> pInstance;
 
     ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex());
 
     pInstance = mpInstance.lock();
     if (pInstance.get() == NULL)
     {
-        pInstance = ::boost::shared_ptr<PageCacheManager>(
+        pInstance = std::shared_ptr<PageCacheManager>(
             new PageCacheManager(),
             PageCacheManager::Deleter());
         mpInstance = pInstance;
@@ -191,11 +191,11 @@ PageCacheManager::~PageCacheManager()
 {
 }
 
-::boost::shared_ptr<PageCacheManager::Cache> PageCacheManager::GetCache (
+std::shared_ptr<PageCacheManager::Cache> PageCacheManager::GetCache (
     DocumentKey pDocument,
     const Size& rPreviewSize)
 {
-    ::boost::shared_ptr<Cache> pResult;
+    std::shared_ptr<Cache> pResult;
 
     // Look for the cache in the list of active caches.
     CacheDescriptor aKey (pDocument, rPreviewSize);
@@ -224,7 +224,7 @@ PageCacheManager::~PageCacheManager()
 }
 
 void PageCacheManager::Recycle (
-    const ::boost::shared_ptr<Cache>& rpCache,
+    const std::shared_ptr<Cache>& rpCache,
     DocumentKey pDocument,
     const Size& rPreviewSize)
 {
@@ -258,7 +258,7 @@ void PageCacheManager::Recycle (
     }
 }
 
-void PageCacheManager::ReleaseCache (const ::boost::shared_ptr<Cache>& rpCache)
+void PageCacheManager::ReleaseCache (const std::shared_ptr<Cache>& rpCache)
 {
     PageCacheContainer::iterator iCache (::std::find_if(
         mpPageCaches->begin(),
@@ -275,14 +275,14 @@ void PageCacheManager::ReleaseCache (const ::boost::shared_ptr<Cache>& rpCache)
     }
 }
 
-::boost::shared_ptr<PageCacheManager::Cache> PageCacheManager::ChangeSize (
-    const ::boost::shared_ptr<Cache>& rpCache,
+std::shared_ptr<PageCacheManager::Cache> PageCacheManager::ChangeSize (
+    const std::shared_ptr<Cache>& rpCache,
     const Size& rOldPreviewSize,
     const Size& rNewPreviewSize)
 {
     (void)rOldPreviewSize;
 
-    ::boost::shared_ptr<Cache> pResult;
+    std::shared_ptr<Cache> pResult;
 
     if (rpCache.get() != NULL)
     {
@@ -388,11 +388,11 @@ void PageCacheManager::ReleasePreviewBitmap (const SdrPage* pPage)
         iCache->second->ReleaseBitmap(pPage);
 }
 
-::boost::shared_ptr<PageCacheManager::Cache> PageCacheManager::GetRecentlyUsedCache (
+std::shared_ptr<PageCacheManager::Cache> PageCacheManager::GetRecentlyUsedCache (
     DocumentKey pDocument,
     const Size& rPreviewSize)
 {
-    ::boost::shared_ptr<Cache> pCache;
+    std::shared_ptr<Cache> pCache;
 
     // Look for the cache in the list of recently used caches.
     RecentlyUsedPageCaches::iterator iQueue (mpRecentlyUsedPageCaches->find(pDocument));
@@ -414,7 +414,7 @@ void PageCacheManager::ReleasePreviewBitmap (const SdrPage* pPage)
 void PageCacheManager::PutRecentlyUsedCache(
     DocumentKey pDocument,
     const Size& rPreviewSize,
-    const ::boost::shared_ptr<Cache>& rpCache)
+    const std::shared_ptr<Cache>& rpCache)
 {
     // Look up the list of recently used caches for the given document.
     RecentlyUsedPageCaches::iterator iQueue (mpRecentlyUsedPageCaches->find(pDocument));
diff --git a/sd/source/ui/slidesorter/cache/SlsQueueProcessor.cxx b/sd/source/ui/slidesorter/cache/SlsQueueProcessor.cxx
index 212734e3df0b..b3ef313c100a 100644
--- a/sd/source/ui/slidesorter/cache/SlsQueueProcessor.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsQueueProcessor.cxx
@@ -27,7 +27,7 @@ namespace sd { namespace slidesorter { namespace cache {
 
 QueueProcessor::QueueProcessor (
     RequestQueue& rQueue,
-    const ::boost::shared_ptr<BitmapCache>& rpCache,
+    const std::shared_ptr<BitmapCache>& rpCache,
     const Size& rPreviewSize,
     const bool bDoSuperSampling,
     const SharedCacheContext& rpCacheContext)
@@ -182,7 +182,7 @@ void QueueProcessor::ProcessOneRequest (
 }
 
 void QueueProcessor::SetBitmapCache (
-    const ::boost::shared_ptr<BitmapCache>& rpCache)
+    const std::shared_ptr<BitmapCache>& rpCache)
 {
     mpCache = rpCache;
 }
diff --git a/sd/source/ui/slidesorter/cache/SlsQueueProcessor.hxx b/sd/source/ui/slidesorter/cache/SlsQueueProcessor.hxx
index 40fd28b59ce9..906e2e84beb9 100644
--- a/sd/source/ui/slidesorter/cache/SlsQueueProcessor.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsQueueProcessor.hxx
@@ -55,7 +55,7 @@ public:
     typedef ::std::function<bool ()> IdleDetectionCallback;
     QueueProcessor (
         RequestQueue& rQueue,
-        const ::boost::shared_ptr<BitmapCache>& rpCache,
+        const std::shared_ptr<BitmapCache>& rpCache,
         const Size& rPreviewSize,
         const bool bDoSuperSampling,
         const SharedCacheContext& rpCacheContext);
@@ -83,7 +83,7 @@ public:
         BitmapCache.  This is usually necessary after calling
         PageCacheManager::ChangeSize().
     */
-    void SetBitmapCache (const ::boost::shared_ptr<BitmapCache>& rpCache);
+    void SetBitmapCache (const std::shared_ptr<BitmapCache>& rpCache);
 
 private:
     /** This mutex is used to guard the queue processor.  Be careful not to
@@ -100,7 +100,7 @@ private:
     bool mbDoSuperSampling;
     SharedCacheContext mpCacheContext;
     RequestQueue& mrQueue;
-    ::boost::shared_ptr<BitmapCache> mpCache;
+    std::shared_ptr<BitmapCache> mpCache;
     BitmapFactory maBitmapFactory;
     bool mbIsPaused;
 
diff --git a/sd/source/ui/slidesorter/cache/SlsRequestFactory.cxx b/sd/source/ui/slidesorter/cache/SlsRequestFactory.cxx
index ce4b860710d7..aec7035c3f33 100644
--- a/sd/source/ui/slidesorter/cache/SlsRequestFactory.cxx
+++ b/sd/source/ui/slidesorter/cache/SlsRequestFactory.cxx
@@ -34,7 +34,7 @@ void RequestFactory::operator()(
     RequestQueue& rRequestQueue,
     const SharedCacheContext& rpCacheContext)
 {
-    ::boost::shared_ptr<std::vector<CacheKey> > aKeys;
+    std::shared_ptr<std::vector<CacheKey> > aKeys;
 
     // Add the requests for the visible pages.
     aKeys = rpCacheContext->GetEntryList(true);
diff --git a/sd/source/ui/slidesorter/cache/SlsRequestQueue.hxx b/sd/source/ui/slidesorter/cache/SlsRequestQueue.hxx
index 21b47c24bef7..a499b16956d6 100644
--- a/sd/source/ui/slidesorter/cache/SlsRequestQueue.hxx
+++ b/sd/source/ui/slidesorter/cache/SlsRequestQueue.hxx
@@ -27,7 +27,7 @@
 #include <osl/mutex.hxx>
 #include <svx/sdrpageuser.hxx>
 
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 
 namespace sd { namespace slidesorter { namespace cache {
@@ -110,7 +110,7 @@ public:
 private:
     ::osl::Mutex maMutex;
     class Container;
-    ::boost::scoped_ptr<Container> mpRequestQueue;
+    std::unique_ptr<Container> mpRequestQueue;
     SharedCacheContext mpCacheContext;
 
     /** A lower bound of the lowest priority of all elements in the queues.