last changes from bloomberg.

cpp/cpp11/trnx_vector.h

@@ -0,0 +1,224 @@
+#ifndef INCLUDED_TRNX_VECTOR
+#define INCLUDED_TRNX_VECTOR
+
+#include <cstddef>
+#include <exception>
+#include <iterator>
+#include <type_traits>
+#include <memory>
+#include <trnx_vector_impl.h>
+
+namespace trnx {
+
+template <typename T>
+class vector
+{
+public:
+    typedef T              value_type;
+    typedef std::size_t    size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T&             reference;
+    typedef const T&       const_reference;
+    typedef T*             pointer;
+    typedef const T*       const_pointer;
+
+private:
+    size_type d_size;
+    size_type d_capacity;
+    typedef detail::uninitialized<T> buff_type[];
+    std::unique_ptr<buff_type> d_buff;
+        // `uninitialized<T>` represents enough uninitialized storage for an
+        // instance of `T`. The lifetime of the `T` instance is controlled
+        // manually via the `.construct` and `.destroy` member functions.
+        // An initialized instance can be accessed through `.get`.
+
+public:
+    typedef detail::iter_impl<detail::uninitialized<T> >       iterator;            //CHG
+    typedef detail::iter_impl<const detail::uninitialized<T> > const_iterator;      //CHG
+        // `iter_impl` is an iterator type that automatically transforms
+        // `uninitialized<T>*` into `T*` when dereferencing.
+
+    vector() : d_size(0), d_capacity(0), d_buff(nullptr)
+    {
+        // A default-constructed vector is empty and has no allocated buffer.
+    }
+
+    vector(const vector& rhs)
+        : d_size(rhs.d_size),
+          d_capacity(rhs.d_capacity),
+
+          // Allocate enough space for `rhs.d_size` items.
+          d_buff(std::make_unique<buff_type>(rhs.d_size))
+    {
+        // Copy-construct all of `rhs`'s elements into the current buffer.
+        for(size_type i = 0; i < d_size; ++i)
+        {
+            d_buff[i].construct(rhs.d_buff[i].get());
+        }
+    }
+
+    ~vector()
+    {
+        // Destroy all elements in the vector. In the Standard, the order of
+        // destruction is unspecified.
+        for(size_type i = 0; i < d_size; ++i)
+        {
+            d_buff[i].destroy();
+        }
+    }
+
+    vector<T>& operator=(const vector<T>& rhs);
+        // The copy-constructor allocates enough memory to store `rhs`'s
+        // elements in a new buffer, copies over the current elements to the
+        // new buffer, and finally sets `d_buff` to point to the new buffer.
+
+    size_type size() const     { return d_size; }
+    size_type capacity() const { return d_capacity; }
+    bool empty() const         { return d_size == 0; }
+
+    iterator begin()       { return iterator(d_buff.get()); }
+    iterator begin() const { return iterator(d_buff.get()); }
+
+    iterator end()         { return iterator(d_buff.get() + d_size); }
+    iterator end() const   { return iterator(d_buff.get() + d_size); }
+
+    const_iterator cbegin() const { return const_iterator(d_buff.get()); }
+    const_iterator cend() const   { return const_iterator(d_buff.get() + d_size); }
+
+    reference front()             { return d_buff[0].get(); }
+    const_reference front() const { return d_buff[0].get(); }
+
+    reference back()              { return d_buff[d_size - 1].get(); }
+    const_reference back() const  { return d_buff[d_size - 1].get(); }
+
+    reference operator[](size_type i)             { return d_buff[i].get(); }
+    const_reference operator[](size_type i) const { return d_buff[i].get(); }
+
+    reference at(size_type i)
+    {
+        if(i >= d_size)
+        {
+            throw std::out_of_range("Index out of range");
+        }
+        else
+        {
+            return d_buff[i].get();
+        }
+    }
+
+    const_reference at(size_type i) const
+    {
+        // The following use of `const_cast` is legal and simply prevents code
+        // repetition with the non-`const` version of `at`.
+        return const_cast<vector<T>&>(*this).at(i);
+    }
+
+    void push_back(const T& item);
+    void push_back(T&& item);
+    void pop_back();
+    void clear();
+    void reserve(size_type new_capacity);
+};
+
+template <typename T>
+void vector<T>::push_back(const T& item)
+{
+    if(d_size >= d_capacity)
+    {
+        const size_type new_capacity = (d_capacity == 0) ? 1
+                                                         : d_capacity * 2;
+
+        reserve(new_capacity);
+    }
+
+    d_buff[d_size++].construct(item);
+}
+
+template <typename T>
+void vector<T>::push_back(T&& item)
+{
+    if(d_size >= d_capacity)
+    {
+        const size_type new_capacity = (d_capacity == 0) ? 1
+                                                         : d_capacity * 2;
+
+        reserve(new_capacity);
+    }
+
+    d_buff[d_size++].construct(std::move(item));
+}
+
+template <typename T>
+void vector<T>::pop_back()
+{
+    BSLS_ASSERT(!empty());
+
+    d_buff[d_size - 1].destroy();
+    --d_size;
+}
+
+template <typename T>
+void vector<T>::clear()
+{
+    // Destroy all existing elements
+    for(size_type i = 0; i < d_size; ++i)
+    {
+        d_buff[i].destroy();
+    }
+
+    // Set size to zero, but leave capacity unchanged
+    d_size = 0;
+}
+
+template <typename T>
+vector<T>& vector<T>::operator=(const vector& rhs)
+{
+    // Prevent self-assignment
+    if(&rhs != this)
+    {
+        // Destroy all existing elements and set size to zero
+        clear();
+
+        // Reserve if necessary
+        reserve(rhs.d_size);
+
+        // Copy elements from `rhs`
+        for(size_type i = 0; i < rhs.d_size; ++i)
+        {
+            d_buff[i].construct(rhs.d_buff[i].get());
+        }
+
+        // Update size
+        d_size = rhs.d_size;
+    }
+
+    return *this;
+}
+
+template <typename T>
+void vector<T>::reserve(size_type new_capacity)
+{
+    // Exit early if there's no need to reserve more memory
+    if(new_capacity <= d_capacity) { return; }
+
+    // Allocate a new buffer
+    auto buff = std::make_unique<buff_type>(new_capacity);
+
+    // Copy-construct existing elements into the new buffer and destroy them
+    // in the old one
+    for(size_type i = 0; i < d_size; ++i)
+    {
+        buff[i].construct(std::move(d_buff[i].get()));
+        d_buff[i].destroy();
+    }
+
+    // Deallocate old buffer, set the owned buffer to `buff`
+    d_buff = std::move(buff);
+
+    // Update capacity
+    d_capacity = new_capacity;
+}
+
+} // close namespace trnx
+
+#endif