google::protobuf::RepeatedField< Element > Singleton Reference

#include <message.h>

Public Types
typedef Element *	iterator
typedef const Element *	const_iterator
typedef Element	value_type
typedef value_type &	reference
typedef const value_type &	const_reference
typedef value_type *	pointer
typedef const value_type *	const_pointer
typedef int	size_type
typedef ptrdiff_t	difference_type
typedef std::reverse_iterator < const_iterator >	const_reverse_iterator
typedef std::reverse_iterator < iterator >	reverse_iterator

Public Member Functions
	RepeatedField ()
	RepeatedField (const RepeatedField &other)
template<typename Iter >
	RepeatedField (Iter begin, const Iter &end)
	~RepeatedField ()
RepeatedField &	operator= (const RepeatedField &other)
bool	empty () const
int	size () const
const Element &	Get (int index) const
Element *	Mutable (int index)
void	Set (int index, const Element &value)
void	Add (const Element &value)
Element *	Add ()
void	RemoveLast ()
void	ExtractSubrange (int start, int num, Element *elements)
void	Clear ()
void	MergeFrom (const RepeatedField &other)
void	CopyFrom (const RepeatedField &other)
void	Reserve (int new_size)
void	Truncate (int new_size)
void	AddAlreadyReserved (const Element &value)
Element *	AddAlreadyReserved ()
int	Capacity () const
void	Resize (int new_size, const Element &value)
Element *	mutable_data ()
const Element *	data () const
void	Swap (RepeatedField *other)
void	SwapElements (int index1, int index2)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
int	SpaceUsedExcludingSelf () const

Private Member Functions
void	MoveArray (Element to[], Element from[], int size)
void	CopyArray (Element to[], const Element from[], int size)

Private Attributes
Element *	elements_
int	current_size_
int	total_size_

Static Private Attributes
static const int	kInitialSize = 0

Member Typedef Documentation

template<typename Element>

typedef const Element* google::protobuf::RepeatedField< Element >::const_iterator

template<typename Element>

typedef const value_type* google::protobuf::RepeatedField< Element >::const_pointer

template<typename Element>

typedef const value_type& google::protobuf::RepeatedField< Element >::const_reference

template<typename Element>

typedef std::reverse_iterator<const_iterator> google::protobuf::RepeatedField< Element >::const_reverse_iterator

template<typename Element>

typedef ptrdiff_t google::protobuf::RepeatedField< Element >::difference_type

template<typename Element>

typedef Element* google::protobuf::RepeatedField< Element >::iterator

template<typename Element>

typedef value_type* google::protobuf::RepeatedField< Element >::pointer

template<typename Element>

typedef value_type& google::protobuf::RepeatedField< Element >::reference

template<typename Element>

typedef std::reverse_iterator<iterator> google::protobuf::RepeatedField< Element >::reverse_iterator

template<typename Element>

typedef int google::protobuf::RepeatedField< Element >::size_type

template<typename Element>

typedef Element google::protobuf::RepeatedField< Element >::value_type

Constructor & Destructor Documentation

template<typename Element >

google::protobuf::RepeatedField< Element >::RepeatedField ( )

inline

 : elements_(NULL),
 current_size_(0),
 total_size_(kInitialSize) {
}

template<typename Element >

google::protobuf::RepeatedField< Element >::RepeatedField ( const RepeatedField< Element > &  other )

inline

 : elements_(NULL),
 current_size_(0),
 total_size_(kInitialSize) {
 CopyFrom(other);
}

Here is the call graph for this function:

template<typename Element >

template<typename Iter >

google::protobuf::RepeatedField< Element >::RepeatedField ( Iter  begin, const Iter &  end  )

inline

 : elements_(NULL),
 current_size_(0),
 total_size_(kInitialSize) {
 int reserve = internal::CalculateReserve(begin, end);
 if (reserve != -1) {
 Reserve(reserve);
 for (; begin != end; ++begin) {
 AddAlreadyReserved(*begin);
 }
 } else {
 for (; begin != end; ++begin) {
 Add(*begin);
 }
 }
}

Here is the call graph for this function:

template<typename Element >

google::protobuf::RepeatedField< Element >::~RepeatedField

(

)

 {
 delete [] elements_;
}

Member Function Documentation

template<typename Element>

void google::protobuf::RepeatedField< Element >::Add ( const Element &  value )

inline

 {
 if (current_size_ == total_size_) Reserve(total_size_ + 1);
 elements_[current_size_++] = value;
}

Here is the caller graph for this function:

template<typename Element>

Element * google::protobuf::RepeatedField< Element >::Add ( )

inline

 {
 if (current_size_ == total_size_) Reserve(total_size_ + 1);
 return &elements_[current_size_++];
}

Here is the caller graph for this function:

template<typename Element>

void google::protobuf::RepeatedField< Element >::AddAlreadyReserved ( const Element &  value )

inline

 {
 GOOGLE_DCHECK_LT(size(), Capacity());
 elements_[current_size_++] = value;
}

Here is the caller graph for this function:

template<typename Element>

Element * google::protobuf::RepeatedField< Element >::AddAlreadyReserved ( )

inline

 {
 GOOGLE_DCHECK_LT(size(), Capacity());
 return &elements_[current_size_++];
}

Here is the caller graph for this function:

template<typename Element >

RepeatedField< Element >::iterator google::protobuf::RepeatedField< Element >::begin ( )

inline

 {
 return elements_;
}

Here is the caller graph for this function:

template<typename Element >

RepeatedField< Element >::const_iterator google::protobuf::RepeatedField< Element >::begin ( ) const

inline

 {
 return elements_;
}

template<typename Element >

int google::protobuf::RepeatedField< Element >::Capacity ( ) const

inline

 {
 return total_size_;
}

Here is the caller graph for this function:

template<typename Element >

void google::protobuf::RepeatedField< Element >::Clear ( )

inline

 {
 current_size_ = 0;
}

Here is the caller graph for this function:

template<typename Element>

void google::protobuf::RepeatedField< Element >::CopyArray ( Element  to[], const Element  from[], int  size  )

inlineprivate

 {
 internal::ElementCopier<Element>()(to, from, array_size);
}

template<typename Element >

void google::protobuf::RepeatedField< Element >::CopyFrom ( const RepeatedField< Element > &  other )

inline

 {
 if (&other == this) return;
 Clear();
 MergeFrom(other);
}

Here is the caller graph for this function:

template<typename Element >

const Element * google::protobuf::RepeatedField< Element >::data ( ) const

inline

 {
 return elements_;
}

template<typename Element >

bool google::protobuf::RepeatedField< Element >::empty ( ) const

inline

 {
 return current_size_ == 0;
}

template<typename Element >

RepeatedField< Element >::iterator google::protobuf::RepeatedField< Element >::end ( )

inline

 {
 return elements_ + current_size_;
}

Here is the caller graph for this function:

template<typename Element >

RepeatedField< Element >::const_iterator google::protobuf::RepeatedField< Element >::end ( ) const

inline

 {
 return elements_ + current_size_;
}

template<typename Element>

void google::protobuf::RepeatedField< Element >::ExtractSubrange	(	int	start,
		int	num,
		Element *	elements
	)

 {
 GOOGLE_DCHECK_GE(start, 0);
 GOOGLE_DCHECK_GE(num, 0);
 GOOGLE_DCHECK_LE(start + num, this->size());

 // Save the values of the removed elements if requested.
 if (elements != NULL) {
 for (int i = 0; i < num; ++i)
 elements[i] = this->Get(i + start);
 }

 // Slide remaining elements down to fill the gap.
 if (num > 0) {
 for (int i = start + num; i < this->size(); ++i)
 this->Set(i - num, this->Get(i));
 this->Truncate(this->size() - num);
 }
}

template<typename Element >

const Element & google::protobuf::RepeatedField< Element >::Get ( int  index ) const

inline

 {
 GOOGLE_DCHECK_GE(index, 0);
 GOOGLE_DCHECK_LT(index, size());
 return elements_[index];
}

Here is the caller graph for this function:

template<typename Element >

void google::protobuf::RepeatedField< Element >::MergeFrom ( const RepeatedField< Element > &  other )

inline

 {
 GOOGLE_CHECK_NE(&other, this);
 if (other.current_size_ != 0) {
 Reserve(current_size_ + other.current_size_);
 CopyArray(elements_ + current_size_, other.elements_, other.current_size_);
 current_size_ += other.current_size_;
 }
}

template<typename Element>

void google::protobuf::RepeatedField< Element >::MoveArray ( Element  to[], Element  from[], int  size  )

inlineprivate

 {
 CopyArray(to, from, array_size);
}

template<typename Element >

Element * google::protobuf::RepeatedField< Element >::Mutable ( int  index )

inline

 {
 GOOGLE_DCHECK_GE(index, 0);
 GOOGLE_DCHECK_LT(index, size());
 return elements_ + index;
}

template<typename Element >

Element * google::protobuf::RepeatedField< Element >::mutable_data ( )

inline

 {
 return elements_;
}

Here is the caller graph for this function:

template<typename Element >

RepeatedField< Element > & google::protobuf::RepeatedField< Element >::operator= ( const RepeatedField< Element > &  other )

inline

 {
 if (this != &other)
 CopyFrom(other);
 return *this;
}

template<typename Element>

reverse_iterator google::protobuf::RepeatedField< Element >::rbegin ( )

inline

 {
 return reverse_iterator(end());
 }

template<typename Element>

const_reverse_iterator google::protobuf::RepeatedField< Element >::rbegin ( ) const

inline

 {
 return const_reverse_iterator(end());
 }

template<typename Element >

void google::protobuf::RepeatedField< Element >::RemoveLast ( )

inline

 {
 GOOGLE_DCHECK_GT(current_size_, 0);
 --current_size_;
}

template<typename Element>

reverse_iterator google::protobuf::RepeatedField< Element >::rend ( )

inline

 {
 return reverse_iterator(begin());
 }

template<typename Element>

const_reverse_iterator google::protobuf::RepeatedField< Element >::rend ( ) const

inline

 {
 return const_reverse_iterator(begin());
 }

template<typename Element >

void google::protobuf::RepeatedField< Element >::Reserve

(

int

new_size

)

 {
 if (total_size_ >= new_size) return;

 Element* old_elements = elements_;
 total_size_ = max(google::protobuf::internal::kMinRepeatedFieldAllocationSize,
 max(total_size_ * 2, new_size));
 elements_ = new Element[total_size_];
 if (old_elements != NULL) {
 MoveArray(elements_, old_elements, current_size_);
 delete [] old_elements;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Element>

void google::protobuf::RepeatedField< Element >::Resize ( int  new_size, const Element &  value  )

inline

 {
 GOOGLE_DCHECK_GE(new_size, 0);
 if (new_size > size()) {
 Reserve(new_size);
 std::fill(&elements_[current_size_], &elements_[new_size], value);
 }
 current_size_ = new_size;
}

Here is the caller graph for this function:

template<typename Element>

void google::protobuf::RepeatedField< Element >::Set ( int  index, const Element &  value  )

inline

 {
 GOOGLE_DCHECK_GE(index, 0);
 GOOGLE_DCHECK_LT(index, size());
 elements_[index] = value;
}

Here is the caller graph for this function:

template<typename Element >

int google::protobuf::RepeatedField< Element >::size ( ) const

inline

 {
 return current_size_;
}

Here is the caller graph for this function:

template<typename Element >

int google::protobuf::RepeatedField< Element >::SpaceUsedExcludingSelf ( ) const

inline

 {
 return (elements_ != NULL) ? total_size_ * sizeof(elements_[0]) : 0;
}

template<typename Element >

void google::protobuf::RepeatedField< Element >::Swap

(

RepeatedField< Element > *

other

)

 {
 if (this == other) return;
 Element* swap_elements = elements_;
 int swap_current_size = current_size_;
 int swap_total_size = total_size_;

 elements_ = other->elements_;
 current_size_ = other->current_size_;
 total_size_ = other->total_size_;

 other->elements_ = swap_elements;
 other->current_size_ = swap_current_size;
 other->total_size_ = swap_total_size;
}

template<typename Element >

void google::protobuf::RepeatedField< Element >::SwapElements	(	int	index1,
		int	index2
	)

 {
 using std::swap; // enable ADL with fallback
 swap(elements_[index1], elements_[index2]);
}

template<typename Element >

void google::protobuf::RepeatedField< Element >::Truncate ( int  new_size )

inline

 {
 GOOGLE_DCHECK_LE(new_size, current_size_);
 current_size_ = new_size;
}

Here is the caller graph for this function:

Member Data Documentation

template<typename Element>

int google::protobuf::RepeatedField< Element >::current_size_

private

template<typename Element>

Element* google::protobuf::RepeatedField< Element >::elements_

private

template<typename Element>

const int google::protobuf::RepeatedField< Element >::kInitialSize = 0

staticprivate

template<typename Element>

int google::protobuf::RepeatedField< Element >::total_size_

private

---

The documentation for this singleton was generated from the following files:

• dep/protobuf/src/google/protobuf/message.h
• dep/protobuf/src/google/protobuf/repeated_field.h