diff options
Diffstat (limited to 'src/hwpf/include/vector.H')
-rw-r--r-- | src/hwpf/include/vector.H | 851 |
1 files changed, 0 insertions, 851 deletions
diff --git a/src/hwpf/include/vector.H b/src/hwpf/include/vector.H deleted file mode 100644 index 1117017e..00000000 --- a/src/hwpf/include/vector.H +++ /dev/null @@ -1,851 +0,0 @@ -/* IBM_PROLOG_BEGIN_TAG */ -/* This is an automatically generated prolog. */ -/* */ -/* $Source: src/hwpf/include/vector.H $ */ -/* */ -/* OpenPOWER sbe Project */ -/* */ -/* Contributors Listed Below - COPYRIGHT 2016 */ -/* [+] International Business Machines Corp. */ -/* */ -/* */ -/* Licensed under the Apache License, Version 2.0 (the "License"); */ -/* you may not use this file except in compliance with the License. */ -/* You may obtain a copy of the License at */ -/* */ -/* http://www.apache.org/licenses/LICENSE-2.0 */ -/* */ -/* Unless required by applicable law or agreed to in writing, software */ -/* distributed under the License is distributed on an "AS IS" BASIS, */ -/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ -/* implied. See the License for the specific language governing */ -/* permissions and limitations under the License. */ -/* */ -/* IBM_PROLOG_END_TAG */ -#ifndef stl_vector -#define stl_vector - -/** - * @file vector - * @brief simple stl vector template class declaration. - */ - -#include <stddef.h> - -#if !defined( __STDC_LIMIT_MACROS) -#define __STDC_LIMIT_MACROS -#endif -#include <stdint.h> -//#include <new> -#include <algorithm> -#include <assert.h> - -namespace std -{ - - /** - * @class vector - * subset of stl vector - * @note Does not support allocators, reverse iterators. - */ - template <class T> - class vector - { - public: - - typedef T * iterator; - typedef const T * const_iterator; - typedef T & reference; - typedef const T & const_reference; - typedef size_t size_type; - typedef size_t difference_type; - // typedef ptrdiff_t difference_type; - typedef T value_type; - typedef T * pointer; - typedef const T * const_pointer; - - - protected: - - pointer iv_start; - pointer iv_finish; - pointer iv_end_of_storage; - - public: - - /** - * Constructor default - * @post The vector is created with no elements. size() == 0, capacity() == 0 - */ - __attribute__ ((always_inline)) - explicit vector(void) - : - iv_start(NULL), - iv_finish(NULL), - iv_end_of_storage(NULL) - {} - - - /** - * Constructor to create a vector of size n elements of value. - * @param[in] n number of elements to create - * @param[in] value used to create the n elements - * @post The vector is created with n elements of value. - * Storage allocated. size() == n, capacity() == n - */ - explicit vector(size_type n, const T& value = T()) - : - iv_start(NULL), - iv_finish(NULL), - iv_end_of_storage(NULL) - { - reserve(n); - iv_finish = iv_start+n; - ctor_fill(iv_start,iv_finish,value); - } - - - /** - * COPY CTOR create a vector from another vector - * @param[in] x source vector - * @post vector of x.size() is created from x with same # nodes - * size() == capacity() == x.size() - */ - vector(const vector<T>& x) - : - iv_start(NULL), - iv_finish(NULL), - iv_end_of_storage(NULL) - { - reserve(x.size()); - iv_finish = ctor_copy(x.iv_start, x.iv_finish, iv_start); - } - - /** - * CTOR create a vector from a container slice - * @param[in] first iterator first in source sequence - * @param[in] last iterator one past end of source sequence - * @returns None. - * @pre last > first; first,last contained within source vector - * @post vector is created from slice given - */ - template<typename InputIterator> - vector(InputIterator first, InputIterator last) - : - iv_start(NULL), - iv_finish(NULL), - iv_end_of_storage(NULL) - { - // assert(last >= first); - // input iterators only support operator ( ++i, i++,==,!=,*,->,=) - size_type n = 0; - for(InputIterator i = first; i != last; ++i) ++n; - reserve(n); - iv_finish = ctor_copy(first,last,iv_start); - } - - /** - * DTOR - * @post Storage released - */ - __attribute__ ((always_inline)) - ~vector() - { - clear(); // call dtors - free_storage(iv_start); - } - - /** - * Assignment operator. - * @param[in] x A vector. - * @return A vector (for the purpose of multiple assigns). - * @pre None. - * @post *this == x, this->capacity() == x.size(). - * All previously obtained iterators are invalid. - */ - vector<T>& operator=(const vector<T>& x) - { - clear(); - reserve(x.size()); - iv_finish = ctor_copy(x.iv_start, x.iv_finish, iv_start); - return(*this); - } - - // Iterators -------------------- - - /** - * Get iterator to the first vector element - * @return iterator of rist vector element - * @pre None. - * @post None. - */ - __attribute__ ((always_inline)) - iterator begin() - { - return (iv_start); - } - - /** - * Get const_iterator to the first vector element - * @return const_iterator of rist vector element - * @pre None. - * @post None. - */ - __attribute__ ((always_inline)) - const_iterator begin() const - { - return (iv_start); - } - - /** - * Get iterator to the last vector element + 1 - * @return iterator - * @pre None. - * @post None. - */ - __attribute__ ((always_inline)) - iterator end() - { - return (iv_finish); - } - - /** - * Get const_iterator to the last vector element + 1 - * @return const_iterator - * @pre None. - * @post None. - */ - __attribute__ ((always_inline)) - const_iterator end() const - { - return (iv_finish); - } - - /* TODO - Implement only if needed - reverse_iterator rbegin() - { - return(iv_finish -1); - } - - const_reverse_iterator rend() - { - return (iv_start - 1); - } - */ - - // Capacity ----------------------------------------------- - - /** - * Get the number of elements in the container - * @return number of elements in the container - */ - __attribute__ ((always_inline)) - size_type size() const - { - return(iv_finish - iv_start); - } - - /** - * Return the maximum potential size the container could reach. - * @return number of the maximum element count this container could reach - */ - __attribute__ ((always_inline)) - size_type max_size() const - { - return UINT64_MAX/sizeof(T); - } - - /** - * Resize the vector to contain n elements - * @param[in] n new size - * @param[in] x object used to copy to any added elements if size() is increased - * @post All previously obtained iterators are invalid. - * @node if n < size(), vector is truncated. - * if n > size(), vector is padded with copies of x - */ - void resize( size_type n, T x = T()); - - /** - * Get the number of elements the vector can hold before needing to reallocate storage. - * @return element capacity of the vector - * @pre None. - * @post None. - */ - __attribute__ ((always_inline)) - size_type capacity() const - { - return(iv_end_of_storage - iv_start); - } - - /** - * Query for empty container - * @return bool, true if size()==0 else false. - * @pre none - * @post none - */ - __attribute__ ((always_inline)) - bool empty() const - { - return(size() == 0); - } - - /** - * Reserve storage for a given number of elements - * @param[in] n The requested capacity of the vector - * @pre None - * @post If current cpacity() < n then new capcity == n; else no change. - * All previously obtained iterators are invalid - */ - void reserve(size_type n); - - // - Element Access ----------------------------------- - - /** - * Access a mutable reference to an element in the container - * @param An index into the vector - * @return A reference to an element - * @pre 0 <= n < size() - * @post None. - */ - __attribute__ ((always_inline)) - reference operator[](size_type n) - { - return(*(iv_start + n)); - } - - /** - * Access a mutable reference to an element in the container - * @param[in] index An index into the vector - * @return A reference to an element - * @pre 0 <= n < size() - * @post None. - * @note no exception handling - */ - __attribute__ ((always_inline)) - reference at(size_type index) - { - assert(index < size()); - return(*(iv_start + index)); - } - - /** - * Get an immutable reference to an element in the container - * @param[in] index An index into the vector - * @return A const_reference to an object or type T - * @pre 0 <= n < size() - * @post None. - */ - __attribute__ ((always_inline)) - const_reference operator[](size_type index) const - { - assert(index < size()); - return(*(iv_start + index)); - } - - /** - * Get an immutable reference to an element in the container - * @param[in] index An index into the vector - * @return A const_reference to an object or type T - * @pre 0 <= n < size() - * @post None. - * @note no exception handling - */ - __attribute__ ((always_inline)) - const_reference at(size_type index) const - { - assert(index < size()); - return(*(iv_start + index)); - } - - /** - * Get a mutable reference to the first element in the container - * @return reference to first element - * @pre none - * @post None - */ - __attribute__ ((always_inline)) - reference front() - { - return *iv_start; - } - - /** - * Get an Immutable reference to the first element in the container - * @return const_reference to first element - * @pre none - * @post None - */ - __attribute__ ((always_inline)) - const_reference front() const - { - return *iv_start; - } - - /** - * Get a mutable reference to the last element in the container - * @return reference to last element - * @pre none - * @post None - */ - __attribute__ ((always_inline)) - reference back() - { - return *(iv_finish-1); - } - - /** - * Get an Immutable reference to the last element in the container - * @return reference to last element - * @pre none - * @post None - */ - __attribute__ ((always_inline)) - const_reference back() const - { - return *(iv_finish-1); - } - - // -- Modifiers ----------------------------- - - /* - * Assign new content to the vector object - * @param[n] first iterator to first element to copy in - * @param[n] last iterator to last element + 1 to copy in - */ - template <class InputIterator> - void assign (InputIterator first, InputIterator last) - { - clear(); - size_type n = 0; - for(InputIterator i = first; i != last; ++i) ++n; - reserve(n); - iv_finish = ctor_copy(first,last,iv_start); - } - - - /* - * Assign new content to the vector object - * @param[in] n number of elements to assign - * @param[in] x reference to element to copy in - */ - void assign ( size_type n, const T& x) - { - clear(); - reserve(n); - ctor_fill_n(iv_start,n,x); - iv_finish = iv_start + n; - } - - - /** - * Add element to the back of the container - * @param[in] x reference to object used to create new element - * @pre none - * @post All previously obtained iterators are invalid. - */ - __attribute__ ((always_inline)) - void push_back(const T& x) - { - reserve(size() + 1); - new (iv_finish++) T(x); - } - - /** - * Remove the last element in the container - * @return nothing - * @pre size() > 0 - * @post size() decreased by one - */ - __attribute__ ((always_inline)) - void pop_back() - { - erase(iv_finish-1,iv_finish); - } - - /** - * Insert an element into the container at a given position - * @param[in] position iterator to position to insert - * @param[in] x reference of element to insert - * @pre begin() <= position < end() - * @post Element inserted at position, storage adjusted as needed. - * All previously obtained iterators are invalid. - */ - iterator insert(iterator position, const T& x) - { - // iv_start will change if the vector gets resized - so save the offset for - // return. - difference_type offset = position - iv_start; - insert(position, 1, x); - return (iv_start + offset); - } - - /** - * Insert a number of copies of a given elements at a given position - * @param[in] postion iterator, postion to insert elements - * @param[in] n number of elements to insert - * @param[in] x A reference to the object to uses to create the new elements - * @pre begin() <= postion < end() - * @post All previously obtained iterators are invalid. - */ - void insert (iterator position, size_type n, const T& x); - - /** - * Insert a slice into the current container at a given position - * @param[in] position iterator, position to insert slice - * @param[in] first iterator to first element of slice insert - * @param[in] last iterator to last element + 1 of slice to insert - * @pre begin() <= postion <= end(), first < last. - * @post Elements inserted at postition. Storage adjusted as needed. - * All previously obtained iterators are invalid. - * @note element pointed to by last is not inserted. - */ - template <class InputIterator> - void insert (iterator position, InputIterator first, - InputIterator last); - - - /** - * Remove an element from the container - * @param[in] position iterator, position of element to remove - * @return new location of the element that followed the last - * element erased, or end() if the operation erased - * the last element in the sequence. - * @pre begin() <= position < end() - * @post All previously obtained iterators are invalid. - */ - __attribute__ ((always_inline)) - iterator erase(iterator position) - { - return erase(position,position+1); - } - - /** - * Remove a slice of elements from the container - * @param[in] first iterator, postion of the first element to remove - * @param[in] last iterator, postion of the last element + 1 to remove - * @return new location of the element that followed the last - * element erased, or end() if the operation erased - * the last element in the sequence. - * @pre begin() <= first,last <= end(), first <= last. - * @post All previously obtained iterators are invalid. - * @note The element pointed to be last is not deleted. - */ - iterator erase(iterator first, iterator last) - { - assert(last >= first); - assert(first >= iv_start); - assert(first <= iv_finish); - assert(last >= iv_start); - assert(last <= iv_finish); - - last = copy(last,iv_finish,first); - while(last != iv_finish) - { - --iv_finish; - iv_finish->~T(); - } - return first; - } - - - /** - * Swap this vector with another - * @param reference to another vector of this type - */ - void swap(vector<T>& x) - { - std::swap(iv_start,x.iv_start); - std::swap(iv_finish,x.iv_finish); - std::swap(iv_end_of_storage,x.iv_end_of_storage); - } - - /** - * Clear the vector - * @pre none. - * @post size() = 0, All previously obtained iterators are invalid - * @note capacity unchanged - */ - void clear () - { - while(iv_finish != iv_start) - { - --iv_finish; - (iv_finish)->~T(); - } - } - - private: - - /** - * Copy constructs elements into raw storage - * @param[in] first iterator of first element to copy - * @pararm[in] last iterator of last element + 1 to copy - * @param[in] destination iterator of destination - * @post elements moved - */ - template <class InputIterator, class OutputIterator> - OutputIterator - ctor_copy(InputIterator first, - InputIterator last, - OutputIterator destination) - { - while(first != last) - { - new (destination) T(*first); - ++destination; - ++first; - } - return(destination); - } - - /** - * Copy constructs elements into raw storage - * @param[in] first iterator of first element to copy - * @param[in] last iterator of last element + 1 to copy - * @param[in] destination iterator to end of destination + 1 - * @post elements moved - */ - template <class BidirectionalIterator1, class BidirectionalIterator2> - BidirectionalIterator2 - ctor_copy_backward ( BidirectionalIterator1 first, - BidirectionalIterator1 last, - BidirectionalIterator2 destination) - { - while(last != first) - { - --destination; - --last; - new(destination) T(*last); - } - return destination; - } - - /** - * fill by copy construct ino raw storage - * @param[in] first itertor fo first element - * @param[in] last iterator to last element + 1 - * @param[in] value to use to fill - */ - template < class ForwardIterator, class Tp > - void - ctor_fill (ForwardIterator first, ForwardIterator last, const Tp& value ) - { - while (first != last) - { - new (first) T(value); - ++first; - } - } - - /** - * fill by copy construct into raw storage - * @param[in] first iterator first location to fill - * @param[in] n number of elements to fill - * @param[in] value to use to fill - */ - template < class OutputIterator, class Size, class Tp > - void - ctor_fill_n( OutputIterator first, Size n, const Tp& value ) - { - for(; n>0; --n) - { - new (first) T(value); - ++first; - } - } - - - /** - * Free all the storage allocated to this vector - * @param[in] i_start iterator to start of storage block - */ - __attribute__ ((always_inline)) - void free_storage(iterator i_start) - { - delete [] (uint8_t *)i_start; - } - - /** - * Allocate storage for this vector - * @param[in] n, number of elements required - */ - __attribute__ ((always_inline)) - iterator allocate_storage(size_type n) - { - return (iterator) new uint8_t[n * sizeof(T)]; - } - - /** - * debug dump - */ - //void dump(const char * msg = "") - //{ - // puts(msg); - // printf("vector_dump::start 0x%016lx finish 0x%016lx eos 0x%016lx\n", - // (uint64_t)iv_start, (uint64_t)iv_finish, (uint64_t)iv_end_of_storage); - //} - }; - -}; // end namespace std - -// ------------------------------------------------------------------------------------------------ - -template <class T> -void std::vector<T>::reserve(size_type n) -{ - size_type c = capacity(); - if(n > c) - { - // if requested new capacity < 10% of current capacity then increase by 10% - size_type dif = n - c; - size_type inc = 1 + (c/size_type(10)); - if(dif < inc) - { - n += inc; - } - - iterator newStart = allocate_storage(n); - if(NULL == iv_start) - { - iv_finish = newStart; - } - else - { - iterator newFinish = ctor_copy(iv_start, iv_finish, newStart); - clear(); - iv_finish = newFinish; - free_storage(iv_start); - } - iv_end_of_storage = newStart + n; - iv_start = newStart; - } -} - - -// ------------------------------------------------------------------------------------------------ - -template <class T> -void std::vector<T>::insert (iterator position, size_type n, const T& x) -{ - //assert (position >= iv_start); - //assert (position <= iv_finish); - size_type new_size = size() + n; - if(position == end()) - { - reserve(new_size); - while(n--) new (iv_finish++) T(x); - } - else if(new_size > capacity()) - { - vector<T> new_vec; - new_vec.reserve(new_size); - for(const_iterator i = begin(); i != end(); ++i) - { - if(i == position) - { - while(n--) new_vec.push_back(x); - } - new_vec.push_back(*i); - } - swap(new_vec); // swap this with new_vec - } - else // already have enough space - { - size_type m = iv_finish - position; // # of existing elements to move - pointer new_finish = iv_finish + n; - if(m < n) - { - ctor_copy_backward(position,iv_finish,new_finish); - while(n--) - { - if(position < iv_finish) *position = x; - else new (position) T(x); - ++position; - } - } - else // n <= m - { - ctor_copy_backward(iv_finish-n,iv_finish,new_finish); // raw storage copy - copy_backward(position, iv_finish-n, iv_finish); // operator= copy - fill_n(position,n,x); - } - iv_finish = new_finish; - } -} - -// ------------------------------------------------------------------------------------------------ - -template <class T> -template <class InputIterator> -void std::vector<T>::insert (iterator position, - InputIterator first, - InputIterator last) -// Should only move storage if there is not room -// InputIterators are not random access (eg. can't do diff = last - first) -{ - size_type n = 0; - for(InputIterator i = first; i != last; ++i) ++n; - size_type new_size = size() + n; - - if(position == end()) - { - reserve(new_size); - iv_finish = ctor_copy(first,last,iv_finish); - } - else if(new_size > capacity()) // make a new vector - { - vector<T> new_vec; - new_vec.reserve(new_size); - for(const_iterator i = begin(); i != end(); ++i) - { - if(i == position) - { - while(n--) new_vec.push_back(*first++); - } - new_vec.push_back(*i); - } - swap(new_vec); - } - else // already have enough space - { - size_type m = iv_finish - position; // # of exising elements to adjust - if(m < n) - { - ctor_copy_backward(position,iv_finish,iv_finish+n); // cp all existing elements to raw storage - while(first != last) - { - if(position < iv_finish) *position = *first; // cp new elements to existing element locations - else new (position) T(*first); // cp remaining new elements to raw storage - ++position; - ++first; - } - } - else // n <= m - { - ctor_copy_backward(iv_finish-n, iv_finish, iv_finish+n); // cp existing elements to raw storage - copy_backward(position, iv_finish-n, iv_finish); // cp rest of existing elements to existing locations - copy(first,last,position); // cp in new elements to existing locations - } - iv_finish += n; - } -} - -// ------------------------------------------------------------------------------------------------ - -template <class T> -void std::vector<T>::resize(size_type n, T x) -{ - size_type sz = size(); - if(n < sz) - { - erase(iv_start + n,iv_finish); - } - else if(n > sz) - { - insert(iv_finish,n-sz,x); - } - // else n == size() do nothing -} - -#endif -/* vim: set filetype=cpp : */ |