GCS  0.2.3
gu_vector.hpp
1 // Copyright (C) 2013 Codership Oy <info@codership.com>
2 
22 #ifndef _GU_VECTOR_HPP_
23 #define _GU_VECTOR_HPP_
24 
25 #include "gu_reserved_container.hpp"
26 #include <vector>
27 
28 namespace gu
29 {
30 
31 /* gu::VectorBase is an interface to generalize gu::Vector template over
32  * capacity so that it is possible to pass gu::Vector<T,capacity> objects
33  * by reference to gu::VectorBase<T> */
34 template <typename T>
36 {
37 public:
38 
39  typedef T value_type;
40  typedef T& reference;
41  typedef const T& const_reference;
42  typedef typename ReservedAllocator<value_type,0>::size_type size_type;
43 
44  virtual reference operator[] (size_type i) = 0;
45  virtual const_reference operator[] (size_type i) const = 0;
46 
47  virtual size_type size () const = 0;
48  virtual void reserve (size_type n) = 0;
49  virtual void resize (size_type n, value_type val = value_type()) = 0;
50 
51  // Now iterators, which I have no time for ATM. Leaving unfinished.
52 
53 protected:
54 
55  VectorBase() {}
56  virtual ~VectorBase() {}
57 };
58 
59 /* a base class to be used as a member of other classes */
60 template <typename T, typename VectorBase<T>::size_type capacity>
61 class Vector
62 {
63 public:
64 
65  Vector() : rv_() {}
66 
67  Vector(const Vector& other) : rv_()
68  {
69  rv_().assign(other().begin(), other().end());
70  }
71 
72  Vector& operator= (Vector other)
73  {
74  using namespace std;
75  swap(other);
76  return *this;
77  }
78 
80  typedef std::vector<T, Allocator> ContainerType;
81 
82  ContainerType& operator() () { return rv_.container(); }
83  const ContainerType& operator() () const { return rv_.container(); }
84 
85  ContainerType* operator-> () { return rv_.operator->(); }
86  const ContainerType* operator-> () const { return rv_.operator->(); }
87 
88  typedef typename VectorBase<T>::size_type size_type;
89 
90  T& operator[] (size_type i) { return operator()()[i]; }
91  const T& operator[] (size_type i) const { return operator()()[i]; }
92 
93  size_type size () const { return operator()().size(); }
94  void reserve (size_type n) { operator()().reserve(n); }
95 
96  typedef typename VectorBase<T>::value_type value_type;
97 
98  void resize (size_type n, value_type val = value_type())
99  {
100  operator()().resize(n, val);
101  }
102 
103  bool in_heap() const // for testing
104  {
105  return (rv_.reserved_buffer() != &rv_.container()[0]);
106  }
107 
108 private:
109 
111 
112 }; /* class Vector*/
113 
114 /* Vector class derived from VectorBase - to be passed as a parameter */
115 template <typename T, typename VectorBase<T>::size_type capacity>
116 class VectorDerived : public VectorBase<T>
117 {
118 public:
119 
120  typedef typename VectorBase<T>::size_type size_type;
121  typedef typename VectorBase<T>::value_type value_type;
122  typedef typename VectorBase<T>::reference reference;
123  typedef typename VectorBase<T>::const_reference const_reference;
124 
125  VectorDerived() : VectorBase<T>(), v_() {}
126 
127  template <typename VectorBase<T>::size_type C>
128  VectorDerived(const Vector<T,C>& other) : VectorBase<T>(), v_()
129  {
130  v_().assign(other().begin(), other().end());
131  }
132 
133  reference operator[] (size_type i) { return v_[i]; }
134  const_reference operator[] (size_type i) const { return v_[i]; }
135 
136  size_type size () const { return v_.size(); }
137  void reserve (size_type n) { v_.reserve(); }
138  void resize (size_type n, value_type val = value_type())
139  {
140  v_.resize();
141  }
142 
143 private:
144 
146 
147 }; /* class VectorDerived */
148 
149 } /* namespace gu */
150 
151 #endif /* _GU_VECTOR_HPP_ */
Definition: gu_vector.hpp:116
Definition: gu_vector.hpp:61
Definition: gu_reserved_container.hpp:46
Definition: gu_vector.hpp:35