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