cc/base/list_container_helper.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_BASE_LIST_CONTAINER_HELPER_H_
   6 #define CC_BASE_LIST_CONTAINER_HELPER_H_
   7
   8 #include "base/memory/scoped_ptr.h"
   9 #include "cc/base/cc_export.h"
  10
  11 namespace cc {
  12
  13 // Helper class for ListContainer non-templated logic. All methods are private,
  14 // and only exposed to friend classes.
  15 // For usage, see comments in ListContainer (list_container.h).
  16 class CC_EXPORT ListContainerHelper final {
  17  private:
  18   template <typename T>
  19   friend class ListContainer;
  20
  21   template <typename T>
  22   friend class RandomAccessListContainer;
  23
  24   explicit ListContainerHelper(size_t max_size_for_derived_class);
  25   ListContainerHelper(size_t max_size_for_derived_class,
  26                       size_t num_of_elements_to_reserve_for);
  27   ~ListContainerHelper();
  28
  29   // This class deals only with char* and void*. It does allocation and passing
  30   // out raw pointers, as well as memory deallocation when being destroyed.
  31   class CharAllocator;
  32
  33   // This class points to a certain position inside memory of
  34   // CharAllocator. It is a base class for ListContainer iterators.
  35   struct CC_EXPORT PositionInCharAllocator {
  36     CharAllocator* ptr_to_container;
  37     size_t vector_index;
  38     char* item_iterator;
  39
  40     PositionInCharAllocator(const PositionInCharAllocator& other);
  41
  42     PositionInCharAllocator(CharAllocator* container,
  43                             size_t vector_ind,
  44                             char* item_iter);
  45
  46     bool operator==(const PositionInCharAllocator& other) const;
  47     bool operator!=(const PositionInCharAllocator& other) const;
  48
  49     PositionInCharAllocator Increment();
  50     PositionInCharAllocator ReverseIncrement();
  51   };
  52
  53   // Iterator classes that can be used to access data.
  54   /////////////////////////////////////////////////////////////////
  55   class CC_EXPORT Iterator : public PositionInCharAllocator {
  56     // This class is only defined to forward iterate through
  57     // CharAllocator.
  58    public:
  59     Iterator(CharAllocator* container,
  60              size_t vector_ind,
  61              char* item_iter,
  62              size_t index);
  63     ~Iterator();
  64
  65     size_t index() const;
  66
  67    protected:
  68     // This is used to track how many increment has happened since begin(). It
  69     // is used to avoid double increment at places an index reference is
  70     // needed. For iterator this means begin() corresponds to index 0 and end()
  71     // corresponds to index |size|.
  72     size_t index_;
  73   };
  74
  75   class CC_EXPORT ConstIterator : public PositionInCharAllocator {
  76     // This class is only defined to forward iterate through
  77     // CharAllocator.
  78    public:
  79     ConstIterator(CharAllocator* container,
  80                   size_t vector_ind,
  81                   char* item_iter,
  82                   size_t index);
  83     ConstIterator(const Iterator& other);  // NOLINT
  84     ~ConstIterator();
  85
  86     size_t index() const;
  87
  88    protected:
  89     // This is used to track how many increment has happened since begin(). It
  90     // is used to avoid double increment at places an index reference is
  91     // needed. For iterator this means begin() corresponds to index 0 and end()
  92     // corresponds to index |size|.
  93     size_t index_;
  94   };
  95
  96   class CC_EXPORT ReverseIterator : public PositionInCharAllocator {
  97     // This class is only defined to reverse iterate through
  98     // CharAllocator.
  99    public:
 100     ReverseIterator(CharAllocator* container,
 101                     size_t vector_ind,
 102                     char* item_iter,
 103                     size_t index);
 104     ~ReverseIterator();
 105
 106     size_t index() const;
 107
 108    protected:
 109     // This is used to track how many increment has happened since rbegin(). It
 110     // is used to avoid double increment at places an index reference is
 111     // needed. For reverse iterator this means rbegin() corresponds to index 0
 112     // and rend() corresponds to index |size|.
 113     size_t index_;
 114   };
 115
 116   class CC_EXPORT ConstReverseIterator : public PositionInCharAllocator {
 117     // This class is only defined to reverse iterate through
 118     // CharAllocator.
 119    public:
 120     ConstReverseIterator(CharAllocator* container,
 121                          size_t vector_ind,
 122                          char* item_iter,
 123                          size_t index);
 124     ConstReverseIterator(const ReverseIterator& other);  // NOLINT
 125     ~ConstReverseIterator();
 126
 127     size_t index() const;
 128
 129    protected:
 130     // This is used to track how many increment has happened since rbegin(). It
 131     // is used to avoid double increment at places an index reference is
 132     // needed. For reverse iterator this means rbegin() corresponds to index 0
 133     // and rend() corresponds to index |size|.
 134     size_t index_;
 135   };
 136
 137   // Unlike the ListContainer methods, these do not invoke element destructors.
 138   void RemoveLast();
 139   void EraseAndInvalidateAllPointers(Iterator* position);
 140   void InsertBeforeAndInvalidateAllPointers(Iterator* position,
 141                                             size_t number_of_elements);
 142
 143   ConstReverseIterator crbegin() const;
 144   ConstReverseIterator crend() const;
 145   ReverseIterator rbegin();
 146   ReverseIterator rend();
 147   ConstIterator cbegin() const;
 148   ConstIterator cend() const;
 149   Iterator begin();
 150   Iterator end();
 151
 152   Iterator IteratorAt(size_t index);
 153   ConstIterator IteratorAt(size_t index) const;
 154
 155   size_t size() const;
 156   bool empty() const;
 157
 158   size_t MaxSizeForDerivedClass() const;
 159
 160   size_t GetCapacityInBytes() const;
 161
 162   // Unlike the ListContainer method, this one does not invoke element
 163   // destructors.
 164   void clear();
 165
 166   size_t AvailableSizeWithoutAnotherAllocationForTesting() const;
 167
 168   // Hands out memory location for an element at the end of data structure.
 169   void* Allocate(size_t size_of_actual_element_in_bytes);
 170
 171   scoped_ptr<CharAllocator> data_;
 172
 173   DISALLOW_COPY_AND_ASSIGN(ListContainerHelper);
 174 };
 175
 176 }  // namespace cc
 177
 178 #endif  // CC_BASE_LIST_CONTAINER_HELPER_H_