InDesign SDK  20.5
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
K2PtrVectorBase.h
1 //========================================================================================
2 //
3 // $File$
4 //
5 // Owner: Mat Marcus
6 //
7 // $Author$
8 //
9 // $DateTime$
10 //
11 // $Revision$
12 //
13 // $Change$
14 //
15 // Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
16 //
17 // NOTICE: Adobe permits you to use, modify, and distribute this file in accordance
18 // with the terms of the Adobe license agreement accompanying it. If you have received
19 // this file from a source other than Adobe, then your use, modification, or
20 // distribution of it requires the prior written permission of Adobe.
21 //
22 //========================================================================================
23 
24 #ifndef __K2PtrVectorBase__
25 #define __K2PtrVectorBase__
26 
27 #include "K2VectorBase.h"
28 
29 // ===================================================================================
30 // K2PtrVectorBase: don not use directly - use K2Vector instead
31 // When Visual C supports it we can use partial class specialization instead
32 // ===================================================================================
33 namespace K2Internals {
34 template <class T/*, class Allocator = K2Allocator<T>*/ > // Can't support Allocators here with VC6 (Rebind crashes compiler)
35 class K2PtrVectorBase {
36 // Classes in K2Internals are not intended to be used directly. Use K2vector instead
37  typedef K2VectorBase<const void*, K2Allocator<const void*> > Inherited;
38  typedef Inherited::allocator_type base_allocator; // really want rebind here
39  typedef K2Allocator<T> Allocator;
40  friend class K2Vector<T, Allocator>;
41 public:
42  typedef object_type data_type;
43 
44  typedef T value_type;
45  typedef value_type* pointer;
46  typedef const value_type* const_pointer;
47  typedef value_type* iterator;
48  typedef const value_type* const_iterator;
49  typedef value_type& reference;
50  typedef const value_type& const_reference;
51  typedef std::size_t size_type;
52  typedef std::ptrdiff_t difference_type;
53  typedef Allocator allocator_type;
54 
55  typedef K2Reverse_iterator<iterator, value_type, difference_type, pointer, reference> reverse_iterator;
56  typedef K2Reverse_iterator<const_iterator, value_type, difference_type, const_pointer, const_reference> const_reverse_iterator;
57 
58 public:
59  explicit K2PtrVectorBase(/*const Allocator& a = Allocator()*/) : fArray(base_allocator()) {}
60  K2PtrVectorBase(size_type count, const T& value/*, const Allocator& a = Allocator()*/)
61  : fArray((Inherited::size_type)count, value) {}
62  K2PtrVectorBase(const_iterator first, const_iterator last/*, const Allocator& a = Allocator()*/)
63  : fArray(Inherited::const_iterator(first), Inherited::const_iterator(last)) {}
64  K2PtrVectorBase(const K2PtrVectorBase& rhs) = default;
65  K2PtrVectorBase(K2PtrVectorBase&& rhs) noexcept = default;
66  K2PtrVectorBase &operator=(const K2PtrVectorBase& rhs) = default;
67  K2PtrVectorBase &operator=(K2PtrVectorBase&& rhs) noexcept = default;
68 
69 public:
70  iterator begin() {return iterator(fArray.begin());}
71  const_iterator begin() const {return const_iterator(fArray.begin());}
72  iterator end() {return iterator(fArray.end());}
73  const_iterator end() const {return const_iterator(fArray.end());}
74  reverse_iterator rbegin() {return reverse_iterator(end());}
75  const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
76  reverse_iterator rend() {return reverse_iterator(begin());}
77  const_reverse_iterator rend() const {return const_reverse_iterator(begin());}
78 
79  size_type size() const {return fArray.size();}
80  size_type max_size() const {return fArray.max_size();}
81  size_type capacity() const {return fArray.capacity();}
82  bool16 empty() const {return fArray.empty();}
83 
84  allocator_type get_allocator() const {return fArray.get_allocator();}
85 
86  void assign(size_type count, const T& v) {fArray.assign((Inherited::size_type)count, v);}
87 
88  template <class InputIter>
89  void assign(InputIter first, InputIter last) { fArray.assign(first, last); }
90 
91  reference operator[](size_type i) {return reference(fArray.operator[]((Inherited::size_type)i));}
92  const_reference operator[](size_type i) const {return const_reference(fArray.operator[]((Inherited::size_type)i));}
93  reference at(size_type i) {return reference(fArray.at((Inherited::size_type)i));}
94  const_reference at(size_type i) const {return const_reference(fArray.at((Inherited::size_type)i));}
95  reference front() {return reference(fArray.front());}
96  const_reference front() const {return const_reference(fArray.front());}
97  reference back() {return reference(fArray.back());}
98  const_reference back() const {return const_reference(fArray.back());}
99 
100  void push_back(const T& x) {fArray.push_back((const void*)x);}
101  void pop_back() {fArray.pop_back();}
102  iterator insert(iterator position, const T& x) {return iterator(fArray.insert(Inherited::iterator(position), (const void*)x));}
103  void insert(iterator position, size_type n, const T& x) {fArray.insert(Inherited::iterator(position), (Inherited::size_type)n, (const void*)x);}
104  template <class InputIter>
105  void insert(iterator pos, InputIter first, InputIter last)
106  {
107  fArray.insert(Inherited::iterator(pos), first, last);
108  }
109 
110 
111  iterator erase(iterator position) {return iterator(fArray.erase(Inherited::iterator(position)));}
112  iterator erase(iterator first, iterator last) {return iterator(fArray.erase(Inherited::iterator(first), Inherited::iterator(last)));}
113  void swap(K2PtrVectorBase& rhs) noexcept {fArray.swap(rhs.fArray);}
114  void clear() {fArray.clear();}
115  //void resize(size_type sz);
116  void resize(size_type sz, const T& value){fArray.resize((Inherited::size_type)sz, value);}
117  void reserve(size_type sz) {fArray.reserve((Inherited::size_type)sz);}
118 
119  void initialize(size_type , const T& ) {}
120  void fill_assign(size_type, const T&) {}
121  void fill_insert(iterator, size_type, const T&){}
122  void CopyConstructHelper(const K2PtrVectorBase&) {}
123 protected:
124  void DoCleanup() {}
125  size_type DoGetCapacity(size_type) {return 0;}
126  void DoReset(pointer, size_type, size_type) {}
127  // Need these for ForceInstantiation.
128 
129 private:
130  Inherited fArray;
131 };
132 
133 template <typename T>
134 inline bool16 operator==(const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());}
135 
136 template <typename T>
137 inline bool16 operator!=(const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return !(lhs == rhs);}
138 
139 template <typename T>
140 inline bool16 operator< (const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());}
141 
142 template <typename T>
143 inline bool16 operator> (const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return rhs < lhs;}
144 
145 template <typename T>
146 inline bool16 operator>=(const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return !(lhs < rhs);}
147 
148 template <typename T>
149 inline bool16 operator<=(const K2PtrVectorBase<T>& lhs, const K2PtrVectorBase<T>& rhs) {return !(rhs < lhs);}
150 
151 template <class T/*, class Allocator*/>
152 inline void swap(K2PtrVectorBase<T/*, Allocator*/>& x, K2PtrVectorBase<T/*, Allocator*/>& y) noexcept
153 {
154  x.swap(y);
155 }
156 } // namespace K2Internals
157 
158 #endif // __K2PtrVectorBase__