printing/page_number.cc

   1 // Copyright 2006-2008 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/page_number.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9
  10 #include "base/check_op.h"
  11 #include "printing/print_job_constants.h"
  12
  13 namespace printing {
  14
  15 PageNumber::PageNumber(const PageRanges& ranges, uint32_t document_page_count) {
  16   Init(ranges, document_page_count);
  17 }
  18
  19 PageNumber::PageNumber()
  20     : ranges_(nullptr),
  21       page_number_(kInvalidPageIndex),
  22       page_range_index_(kInvalidPageIndex),
  23       document_page_count_(0) {}
  24
  25 PageNumber::PageNumber(const PageNumber& other) = default;
  26
  27 PageNumber& PageNumber::operator=(const PageNumber& other) = default;
  28
  29 void PageNumber::Init(const PageRanges& ranges, uint32_t document_page_count) {
  30   DCHECK(document_page_count);
  31   ranges_ = ranges.empty() ? nullptr : &ranges;
  32   document_page_count_ = document_page_count;
  33   if (ranges_) {
  34     uint32_t first_page = (*ranges_)[0].from;
  35     if (first_page < document_page_count) {
  36       page_range_index_ = 0;
  37       page_number_ = (*ranges_)[0].from;
  38     } else {
  39       page_range_index_ = kInvalidPageIndex;
  40       page_number_ = kInvalidPageIndex;
  41     }
  42   } else {
  43     page_range_index_ = kInvalidPageIndex;
  44     page_number_ = 0;
  45   }
  46 }
  47
  48 uint32_t PageNumber::operator++() {
  49   ++page_number_;
  50   if (page_number_ >= document_page_count_) {
  51     // Finished.
  52     *this = npos();
  53   } else if (ranges_ && page_number_ > (*ranges_)[page_range_index_].to) {
  54     DCHECK_LE(ranges_->size(),
  55               static_cast<size_t>(std::numeric_limits<int>::max()));
  56     if (++page_range_index_ == ranges_->size()) {
  57       // Finished.
  58       *this = npos();
  59     } else {
  60       page_number_ = (*ranges_)[page_range_index_].from;
  61       if (page_number_ >= document_page_count_) {
  62         // Finished.
  63         *this = npos();
  64       }
  65     }
  66   }
  67   return ToUint();
  68 }
  69
  70 bool PageNumber::operator==(const PageNumber& other) const {
  71   return page_number_ == other.page_number_ &&
  72          page_range_index_ == other.page_range_index_;
  73 }
  74 bool PageNumber::operator!=(const PageNumber& other) const {
  75   return page_number_ != other.page_number_ ||
  76          page_range_index_ != other.page_range_index_;
  77 }
  78
  79 // static
  80 std::vector<uint32_t> PageNumber::GetPages(PageRanges ranges,
  81                                            uint32_t page_count) {
  82   PageRange::Normalize(ranges);
  83   std::vector<uint32_t> printed_pages;
  84   static constexpr uint32_t kMaxNumberOfPages = 100000;
  85   printed_pages.reserve(std::min(page_count, kMaxNumberOfPages));
  86   for (PageNumber page_number(ranges, std::min(page_count, kMaxNumberOfPages));
  87        page_number != PageNumber::npos(); ++page_number) {
  88     printed_pages.push_back(page_number.ToUint());
  89   }
  90   return printed_pages;
  91 }
  92
  93 }  // namespace printing