X-Git-Url: https://git.ucc.asn.au/?p=tpg%2Facess2.git;a=blobdiff_plain;f=Usermode%2FLibraries%2Flibc%2B%2B.so_src%2Finclude_exp%2Fvector;fp=Usermode%2FLibraries%2Flibc%2B%2B.so_src%2Finclude_exp%2Fvector;h=ab42c9c889fcfb1700535aed5cc33178f4e03438;hp=0000000000000000000000000000000000000000;hb=845b6f9d90bb87b5e760e4d49aa93b0e003ab750;hpb=67a7fe2bb79eceaf10c572a99bd8345c4e81cf5b

diff --git a/Usermode/Libraries/libc++.so_src/include_exp/vector b/Usermode/Libraries/libc++.so_src/include_exp/vector
new file mode 100644
index 00000000..ab42c9c8
--- /dev/null
+++ b/Usermode/Libraries/libc++.so_src/include_exp/vector
@@ -0,0 +1,397 @@
+/*
+ * Acess2 C++ Library
+ * - By John Hodge (thePowersGang)
+ *
+ * vector (header)
+ * - C++'s vector (dynamic array) type
+ */
+#ifndef _LIBCXX_VECTOR_
+#define _LIBCXX_VECTOR_
+
+#include <allocator>
+#include <stdexcept>
+#include <initializer_list>
+
+extern "C" void _SysDebug(const char *, ...);
+
+namespace std {
+
+namespace _bits {
+template <class VectorType, class T>
+class vector_iterator//:
+	//public random_acess_iterator_tag
+{
+	friend VectorType;
+	
+	typedef typename VectorType::size_type	size_type;
+	typedef typename VectorType::difference_type	difference_type;
+	
+	T*	m_array;
+	size_type	m_pos;
+	size_type	m_max;
+public:
+	vector_iterator():
+		vector_iterator(0,0,0)
+	{
+	}
+	vector_iterator(const vector_iterator& x):
+		vector_iterator()
+	{
+		*this = x;
+	}
+	vector_iterator(T* array, size_type start, size_type max):
+		m_array(array),
+		m_pos(start),
+		m_max(max)
+	{
+	}
+	vector_iterator& operator=(const vector_iterator& x)
+	{
+		m_array = x.m_array;
+		m_pos = x.m_pos;
+		m_max = x.m_max;
+		return *this;
+	}
+	bool operator==(const vector_iterator& other) const {
+		return m_pos == other.m_pos;
+	}
+	bool operator!=(const vector_iterator& other) const {
+		return !(*this == other);
+	}
+	T& operator*() const {
+		return m_array[m_pos];
+	}
+	T& operator->() const {
+		return m_array[m_pos];
+	}
+	T& operator[](difference_type n) {
+		return *(*this + n);
+	}
+	vector_iterator& operator++() {
+		if(m_pos < m_max) {
+			m_pos ++;
+		}
+		return *this;
+	}
+	const vector_iterator operator++(int) {
+		vector_iterator ret(*this);
+		++*this;
+		return ret;
+	}
+	vector_iterator& operator--() {
+		if(m_pos > 0) {
+			m_pos --;
+		}
+		return *this;
+	}
+	const vector_iterator operator--(int) {
+		vector_iterator ret(*this);
+		--*this;
+		return ret;
+	}
+	vector_iterator& operator+=(difference_type n) {
+		if( n < 0 )
+			return (*this -= -n);
+		if( n > 0 )
+			m_pos = (m_pos + n < m_max ? m_pos + n : m_max); 
+		return *this;
+	}
+	vector_iterator& operator-=(difference_type n) {
+		if( n < 0 )
+			return (*this += -n);
+		if( n > 0 )
+			m_pos = (m_pos >= n ? m_pos - n : 0);
+		return *this;
+	}
+	const difference_type operator-(const vector_iterator& it2) const {
+		//_libcxx_assert(m_array == it2.m_array);
+		return m_pos - it2.m_pos;
+	}
+	bool operator<(const vector_iterator& o) const { return m_pos < o.m_pos; }
+	bool operator>(const vector_iterator& o) const { return m_pos > o.m_pos; }
+	bool operator<=(const vector_iterator& o) const { return m_pos <= o.m_pos; }
+	bool operator>=(const vector_iterator& o) const { return m_pos >= o.m_pos; }
+};
+#define vector_iterator_tpl class VectorType, class T
+#define vector_iterator	vector_iterator<VectorType, T>
+template <vector_iterator_tpl>
+const vector_iterator operator+(const vector_iterator& it, typename VectorType::difference_type n) {
+	return vector_iterator(it) += n;
+}
+template <vector_iterator_tpl>
+const vector_iterator operator+(typename VectorType::difference_type n, const vector_iterator& it) {
+	return vector_iterator(it) += n;
+}
+template <vector_iterator_tpl>
+const vector_iterator operator-(const vector_iterator& it, typename VectorType::difference_type n) {
+	return vector_iterator(it) -= n;
+}
+#undef vector_iterator_tpl
+#undef vector_iterator
+
+}
+
+template <class T, class Alloc = allocator<T> >
+class vector
+{
+public:
+	typedef T	value_type;
+	typedef Alloc	allocator_type;
+	typedef typename allocator_type::reference	reference;
+	typedef typename allocator_type::const_reference	const_reference;
+	typedef typename allocator_type::pointer	pointer;
+	typedef typename allocator_type::const_pointer	const_pointer;
+	typedef int	difference_type;
+	typedef size_t	size_type;
+	typedef ::std::_bits::vector_iterator<vector,T>	iterator;
+	typedef ::std::_bits::vector_iterator<vector,const T>	const_iterator;
+
+private:
+	allocator_type	m_alloc;
+	size_type	m_size;
+	size_type	m_capacity;
+	value_type*	m_data;
+
+public:	
+	vector(const allocator_type& alloc = allocator_type()):
+		m_alloc(alloc),
+		m_size(0),
+		m_capacity(0),
+		m_data(0)
+	{
+	}
+	vector(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()):
+		vector(alloc)
+	{
+		resize(n, val);
+	}
+	template <class InputIterator>
+	vector(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()):
+		vector(alloc)
+	{
+		insert(begin(), first, last);
+	}
+	vector(const vector& x):
+		vector(x.m_alloc)
+	{
+		*this = x;
+	}
+	#if _CXX11_AVAIL
+	vector(vector&& x):
+		m_alloc(x.m_alloc),
+		m_size(x.m_size),
+		m_capacity(x.m_capacity),
+		m_data(x.m_data)
+	{
+		x.m_data = nullptr;
+		x.m_capacity = 0;
+		x.m_size = 0;
+	}
+	vector(vector&& x, const allocator_type& alloc):
+		m_alloc(alloc),
+		m_size(x.m_size),
+		m_capacity(x.m_capacity),
+		m_data(x.m_data)
+	{
+		x.m_data = nullptr;
+		x.m_capacity = 0;
+		x.m_size = 0;
+	}
+	vector(std::initializer_list<value_type> il, const allocator_type& alloc = allocator_type()):
+		vector(alloc)
+	{
+		reserve(il.size());
+		insert(begin(), il.begin(), il.end());
+	}
+	#endif
+	vector& operator=(const vector& x)
+	{
+		clear();
+		m_alloc.deallocate(m_data, m_capacity);
+		m_capacity = 0;
+		m_data = nullptr;
+		
+		reserve(x.size());
+		for( size_type i = 0; i < x.size(); i ++ )
+			push_back( x[i] );
+		
+		return *this;
+	}
+	
+	~vector()
+	{
+		clear();
+		m_alloc.deallocate(m_data, m_capacity);
+		m_capacity = 0;
+		m_data = nullptr;
+	}
+	
+	// Iterators
+	iterator       begin()       { return iterator_to(0); }
+	const_iterator begin() const { return iterator_to(0); }
+	iterator       end()       { return iterator_to(m_size); }
+	const_iterator end() const { return iterator_to(m_size); }
+	
+	// Capacity
+	size_type size() const {
+		return m_size;
+	}
+	size_type max_size() const {
+		return -1 / sizeof(value_type);
+	}
+	void resize(size_type new_cap, value_type val = value_type()) {
+		reserve(new_cap);
+		if( new_cap > m_size )
+		{
+			for( size_type i = m_size; i < new_cap; i ++ ) {
+				m_alloc.construct( &m_data[i], val );
+			}
+		}
+		else
+		{
+			for( size_type i = new_cap; i < m_size; i ++ )
+				m_alloc.destroy( &m_data[i] );
+		}
+		m_size = new_cap;
+	}
+	size_type capacity() const {
+		return m_capacity;
+	}
+	bool empty() const {
+		return m_size == 0;
+	}
+	void reserve(size_type n) {
+		if( n > max_size() )
+			throw ::std::length_error("::std::vector::reserve");
+		if( n > m_capacity )
+		{
+			size_type size = (n + 0x1F) & ~0x1F;
+			auto new_area = m_alloc.allocate(size);
+			for( size_type i = 0; i < m_size; i ++ )
+				new_area[i] = m_data[i];
+			m_alloc.deallocate(m_data, m_capacity);
+			m_data = new_area;
+			m_capacity = size;
+			//::_SysDebug("::std::vector::resize - m_capacity=%i for n=%i", m_capacity, n);
+		}
+	}
+	void shrink_to_fit() {
+	}
+	
+	// Element access
+	reference operator[] (size_type n) {
+		return m_data[n];
+	}
+	const_reference operator[] (size_type n) const {
+		return m_data[n];
+	}
+	reference at(size_type n) {
+		if(n > size())
+			_throw_out_of_range("::std::vector - at");
+		return m_data[n];
+	}
+	const_reference at(size_type n) const {
+		if(n > size())
+			_throw_out_of_range("::std::vector - at");
+		return m_data[n];
+	}
+	reference front() {
+		return m_data[0];
+	}
+	const_reference front() const {
+		return m_data[0];
+	}
+	reference back() {
+		return m_data[size()-1];
+	}
+	const_reference back() const {
+		return m_data[size()-1];
+	}
+	pointer data() noexcept {
+		return m_data;
+	}
+	const_pointer data() const noexcept {
+		return m_data;
+	}
+	
+	// Modifiers
+	void assign(size_type n, const value_type& val) {
+		clear();
+		resize(n, val);
+	}
+	void push_back(const value_type& val) {
+		resize(size()+1, val);
+	}
+	void pop_back() {
+		if( !empty() ) {
+			resize(size()-1);
+		}
+	}
+	iterator insert(iterator position, const value_type& val) {
+		insert(position, 1, val);
+		return iterator_to(position.m_pos);
+	}
+	void insert(iterator position, size_type n, const value_type& val) {
+		reserve(m_size + n);
+		if( position != end() ) {
+			::_sys::debug("TODO: vector::insert within vector (%i!=%i)",
+				position-begin(), end()-begin());
+			::_sys::abort();
+		}
+		size_type	pos = m_size;
+		while( n -- )
+		{
+			//::_sys::debug("vector::insert - %x at %i", val, pos);
+			m_alloc.construct( &m_data[pos], val );
+			pos ++;
+			m_size ++;
+		}
+	}
+	template <class InputIterator>
+	void insert(iterator position, InputIterator first, InputIterator last) {
+		InputIterator	it = first;
+		size_type	len = 0;
+		while(it != last) {
+			++ it;
+			len ++;
+		}
+		reserve(m_size + len);
+		
+		it = first;
+		while(it != last)
+		{
+			//::_sys::debug("vector::insert - to %i, from %p:%i",
+			//	position.m_pos, it.m_array, it.m_pos);
+			position = insert(position, *it) + 1;
+			++it;
+		}
+	}
+	iterator erase(iterator position);
+	iterator erase(iterator first, iterator last);
+	//void swap(vector& x) {
+	//	::std::swap(m_size, x.m_size);
+	//	::std::swap(m_capacity, x.m_capacity);
+	//	::std::swap(m_data, x.m_data);
+	//}
+	void clear() {
+		for( size_type i = 0; i < m_size; i ++ ) {
+			m_alloc.destroy( &m_data[i] );
+		}
+		m_size = 0;
+	}
+private:
+	iterator iterator_to(size_type index) {
+		_libcxx_assert(index <= m_size);
+		return iterator(m_data, index, m_size);
+	}
+	const_iterator iterator_to(size_type index) const {
+		_libcxx_assert(index <= m_size);
+		return const_iterator(m_data, index, m_size);
+	}
+};
+
+};	// namespace std
+
+#endif
+// vim: ft=cpp
+