sd/source/ui/slidesorter/model/SlsPageEnumeration.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 <sal/config.h>
  21
  22 #include <utility>
  23
  24 #include <boost/noncopyable.hpp>
  25
  26 #include "model/SlideSorterModel.hxx"
  27 #include "model/SlsPageDescriptor.hxx"
  28
  29 using namespace ::sd::slidesorter;
  30 using namespace ::sd::slidesorter::model;
  31
  32 namespace {
  33
  34 class PageEnumerationImpl
  35     : public Enumeration<SharedPageDescriptor>, private boost::noncopyable
  36 {
  37 public:
  38     inline PageEnumerationImpl (
  39         const SlideSorterModel& rModel,
  40         const PageEnumeration::PagePredicate& rPredicate);
  41     virtual ~PageEnumerationImpl();
  42     /** Create a copy of the called enumeration object.
  43     */
  44     virtual ::std::unique_ptr<Enumeration<SharedPageDescriptor> > Clone() SAL_OVERRIDE;
  45
  46     virtual bool HasMoreElements() const SAL_OVERRIDE;
  47     virtual SharedPageDescriptor GetNextElement() SAL_OVERRIDE;
  48     virtual void Rewind() SAL_OVERRIDE;
  49
  50 private:
  51     const SlideSorterModel& mrModel;
  52     const PageEnumeration::PagePredicate maPredicate;
  53     int mnIndex;
  54
  55     /** This constructor sets the internal page index to the given value.
  56         It does not call AdvanceToNextValidElement() to skip elements that
  57         do not fulfill Predicate.
  58     */
  59     inline PageEnumerationImpl (
  60         const SlideSorterModel& rModel,
  61         const PageEnumeration::PagePredicate& rPredicate,
  62         int nIndex);
  63
  64     /** Skip all elements that do not fulfill Predicate starting with the
  65         one pointed to by mnIndex.
  66     */
  67     inline void AdvanceToNextValidElement();
  68 };
  69
  70 } // end of anonymouse namespace
  71
  72 namespace sd { namespace slidesorter { namespace model {
  73
  74 PageEnumeration PageEnumeration::Create (
  75     const SlideSorterModel& rModel,
  76     const PagePredicate& rPredicate)
  77 {
  78     return PageEnumeration(::std::unique_ptr<Enumeration<SharedPageDescriptor> >(
  79         new PageEnumerationImpl(rModel, rPredicate)));
  80 }
  81
  82 PageEnumeration::PageEnumeration (
  83     ::std::unique_ptr<Enumeration<SharedPageDescriptor> > && pImpl)
  84     : mpImpl(std::move(pImpl))
  85 {
  86 }
  87
  88 PageEnumeration::PageEnumeration (
  89     PageEnumeration& rEnumeration,
  90     bool bCloneImpl)
  91 {
  92
  93     if( bCloneImpl )
  94     {
  95         mpImpl = rEnumeration.mpImpl->Clone();
  96     }
  97     else
  98     {
  99         mpImpl = std::move(rEnumeration.mpImpl);
 100     }
 101 }
 102
 103 PageEnumeration::PageEnumeration (const PageEnumeration& rEnumeration )
 104 : sd::slidesorter::model::Enumeration<sd::slidesorter::model::SharedPageDescriptor>()
 105 {
 106     mpImpl = rEnumeration.mpImpl->Clone();
 107 }
 108
 109 PageEnumeration::~PageEnumeration()
 110 {
 111 }
 112
 113 PageEnumeration& PageEnumeration::operator= (
 114     const PageEnumeration& rEnumeration)
 115 {
 116     mpImpl = rEnumeration.mpImpl->Clone();
 117     return *this;
 118 }
 119
 120 ::std::unique_ptr<Enumeration<SharedPageDescriptor> > PageEnumeration::Clone()
 121 {
 122     return ::std::unique_ptr<Enumeration<SharedPageDescriptor> >(
 123         new PageEnumeration (*this, true));
 124 }
 125
 126 bool PageEnumeration::HasMoreElements() const
 127 {
 128     return mpImpl->HasMoreElements();
 129 }
 130
 131 SharedPageDescriptor PageEnumeration::GetNextElement()
 132 {
 133     return mpImpl->GetNextElement();
 134 }
 135
 136 void PageEnumeration::Rewind()
 137 {
 138     return mpImpl->Rewind();
 139 }
 140
 141 } } } // end of namespace ::sd::slidesorter::model
 142
 143 namespace {
 144
 145 PageEnumerationImpl::PageEnumerationImpl (
 146     const SlideSorterModel& rModel,
 147     const PageEnumeration::PagePredicate& rPredicate)
 148     : mrModel(rModel),
 149       maPredicate(rPredicate),
 150       mnIndex(0)
 151 {
 152     Rewind();
 153 }
 154
 155 PageEnumerationImpl::PageEnumerationImpl (
 156     const SlideSorterModel& rModel,
 157     const PageEnumeration::PagePredicate& rPredicate,
 158     int nIndex)
 159     : mrModel(rModel),
 160       maPredicate(rPredicate),
 161       mnIndex(nIndex)
 162 {
 163 }
 164
 165 PageEnumerationImpl::~PageEnumerationImpl()
 166 {
 167 }
 168
 169 ::std::unique_ptr<Enumeration<SharedPageDescriptor> >
 170     PageEnumerationImpl::Clone()
 171 {
 172     return ::std::unique_ptr<Enumeration<SharedPageDescriptor> >(
 173         new PageEnumerationImpl(mrModel,maPredicate,mnIndex));
 174 }
 175
 176 bool PageEnumerationImpl::HasMoreElements() const
 177 {
 178     return (mnIndex < mrModel.GetPageCount());
 179 }
 180
 181 SharedPageDescriptor PageEnumerationImpl::GetNextElement()
 182 {
 183     SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(mnIndex));
 184
 185     // Go to the following valid element.
 186     mnIndex += 1;
 187     AdvanceToNextValidElement();
 188
 189     return pDescriptor;
 190 }
 191
 192 void PageEnumerationImpl::Rewind()
 193 {
 194     // Go to first valid element.
 195     mnIndex = 0;
 196     AdvanceToNextValidElement();
 197 }
 198
 199 void PageEnumerationImpl::AdvanceToNextValidElement()
 200 {
 201     while (mnIndex < mrModel.GetPageCount())
 202     {
 203         SharedPageDescriptor pDescriptor (mrModel.GetPageDescriptor(mnIndex));
 204
 205         // Test for the predicate being fulfilled.
 206         if (pDescriptor.get()!=NULL && maPredicate(pDescriptor))
 207         {
 208             // This predicate is valid.
 209             break;
 210         }
 211         else
 212         {
 213             // Advance to next predicate.
 214             mnIndex += 1;
 215         }
 216     }
 217 }
 218
 219 } // end of anonymous namespace
 220
 221 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */