140 lines
6.3 KiB
C++
140 lines
6.3 KiB
C++
#ifndef _FC_VECTOR_HPP_
|
|
#define _FC_VECTOR_HPP_
|
|
#include <fc/abstract_types.hpp>
|
|
|
|
namespace fc {
|
|
class vector_impl {
|
|
public:
|
|
size_t size()const;
|
|
size_t capacity()const;
|
|
void pop_back();
|
|
void clear();
|
|
void resize( size_t );
|
|
void reserve( size_t );
|
|
|
|
protected:
|
|
vector_impl( abstract_value_type& v, size_t size );
|
|
vector_impl( const vector_impl& );
|
|
vector_impl( vector_impl&& );
|
|
~vector_impl();
|
|
|
|
vector_impl& operator=( const vector_impl& v );
|
|
vector_impl& operator=( vector_impl&& v );
|
|
|
|
void _push_back( const void* v );
|
|
void _push_back_m( void* v );
|
|
|
|
void* _back();
|
|
const void* _back()const;
|
|
|
|
void* _at(size_t);
|
|
const void* _at(size_t)const;
|
|
|
|
void* _insert( void* pos, const void* t );
|
|
void* _insert( void* pos, void* t );
|
|
void* _erase( void* pos );
|
|
void* _erase( void* first, void* last );
|
|
|
|
struct vector_impl_d* my;
|
|
};
|
|
|
|
class vector_pod_impl {
|
|
public:
|
|
size_t size()const;
|
|
size_t capacity()const;
|
|
void pop_back();
|
|
void clear();
|
|
void resize( size_t );
|
|
void reserve( size_t );
|
|
|
|
protected:
|
|
vector_pod_impl( unsigned int size_of, size_t size );
|
|
vector_pod_impl( const vector_pod_impl& );
|
|
vector_pod_impl( vector_pod_impl&& );
|
|
~vector_pod_impl();
|
|
|
|
vector_pod_impl& operator=( const vector_pod_impl& v );
|
|
vector_pod_impl& operator=( vector_pod_impl&& v );
|
|
|
|
void _push_back( const void* v );
|
|
void _push_back_m( void* v );
|
|
|
|
void* _back();
|
|
const void* _back()const;
|
|
|
|
void* _at(size_t);
|
|
const void* _at(size_t)const;
|
|
|
|
void* _insert( void* pos, const void* t );
|
|
void* _erase( void* pos );
|
|
void* _erase( void* first, void* last );
|
|
|
|
struct vector_pod_impl_d* my;
|
|
};
|
|
|
|
template<typename T, bool is_class = true >
|
|
class vector_base : public vector_impl {
|
|
public:
|
|
vector_base( size_t s ):vector_impl( value_type<T>::instance(), s ){};
|
|
vector_base( const vector_base& c ):vector_impl( c ){};
|
|
vector_base( vector_base&& c ):vector_impl( fc::move(c) ){};
|
|
|
|
vector_base& operator=( const vector_base& v ){ vector_impl::operator=(v); return *this; }
|
|
vector_base& operator=( vector_base&& v ) { vector_impl::operator=(fc::move(v)); return *this; }
|
|
};
|
|
|
|
template<typename T>
|
|
class vector_base<T,false> : public vector_pod_impl {
|
|
public:
|
|
vector_base( size_t s ):vector_pod_impl( sizeof(T), s ){};
|
|
vector_base( const vector_base& c ):vector_pod_impl( c ){};
|
|
vector_base( vector_base&& c ):vector_pod_impl( fc::move(c) ){};
|
|
|
|
vector_base& operator=( const vector_base& v ){ vector_pod_impl::operator=(v); return *this; }
|
|
vector_base& operator=( vector_base&& v ) { vector_pod_impl::operator=(fc::move(v)); return *this; }
|
|
};
|
|
|
|
template<typename T>
|
|
class vector : public vector_base<T, fc::is_class<T>::value > {
|
|
public:
|
|
vector( size_t size = 0 ):vector_base<T,fc::is_class<T>::value>( size ){}
|
|
vector( const vector& v ):vector_base<T,fc::is_class<T>::value>(v){}
|
|
vector( vector&& v ):vector_base<T,fc::is_class<T>::value>(fc::move(v)){}
|
|
|
|
vector& operator=( const vector& v ){ vector_base<T,fc::is_class<T>::value>::operator=(v); return *this; }
|
|
vector& operator=( vector&& v ) { vector_base<T,fc::is_class<T>::value>::operator=(fc::move(v)); return *this; }
|
|
|
|
typedef T* iterator;
|
|
typedef const T* const_iterator;
|
|
|
|
T* begin() { return &front(); }
|
|
const T* begin()const { return &front(); }
|
|
const T* end()const { return &back() + 1; }
|
|
|
|
void push_back( const T& t ) { _push_back(&t); }
|
|
void push_back( T&& t ) { _push_back_m(&t); }
|
|
|
|
T& back() { return *((T*)this->_back()); }
|
|
const T& back()const { return *((const T*)this->_back()); }
|
|
|
|
T& front() { return *((T*)this->_at(0)); }
|
|
const T& front()const { return *((const T*)this->_at(0)); }
|
|
|
|
T& operator[]( size_t p ) { return *((T*)this->_at(p)); }
|
|
const T& operator[]( size_t p )const { return *((const T*)this->_at(p)); }
|
|
|
|
T& at( size_t p ) { return *((T*)this->_at(p)); }
|
|
const T& at( size_t p )const { return *((const T*)this->_at(p)); }
|
|
|
|
iterator insert( iterator pos, const T& t ) { return (iterator*)this->_insert( pos, &t ); }
|
|
iterator insert( iterator pos, T&& t ) { return (iterator*)this->_insert_m(pos, &t); }
|
|
iterator erase( iterator pos ) { return (iterator*)this->_erase(pos); }
|
|
iterator erase( iterator first, iterator last ) { return (iterator*)this->_erase(first,last); }
|
|
};
|
|
namespace reflect {
|
|
template<typename T> class reflector;
|
|
template<typename T> class reflector<vector<T>>;
|
|
}
|
|
} // namespace fc
|
|
|
|
#endif // _FC_VECTOR_HPP_
|