google::protobuf::internal::RepeatedPtrFieldBase Class Reference

#include <repeated_field.h>

Protected Member Functions
	RepeatedPtrFieldBase ()
template<typename TypeHandler >
void	Destroy ()
bool	empty () const
int	size () const
template<typename TypeHandler >
const TypeHandler::Type &	Get (int index) const
template<typename TypeHandler >
TypeHandler::Type *	Mutable (int index)
template<typename TypeHandler >
TypeHandler::Type *	Add ()
template<typename TypeHandler >
void	RemoveLast ()
template<typename TypeHandler >
void	Clear ()
template<typename TypeHandler >
void	MergeFrom (const RepeatedPtrFieldBase &other)
template<typename TypeHandler >
void	CopyFrom (const RepeatedPtrFieldBase &other)
void	CloseGap (int start, int num)
void	Reserve (int new_size)
int	Capacity () const
void *const *	raw_data () const
void **	raw_mutable_data () const
template<typename TypeHandler >
TypeHandler::Type **	mutable_data ()
template<typename TypeHandler >
const TypeHandler::Type *const *	data () const
void	Swap (RepeatedPtrFieldBase *other)
void	SwapElements (int index1, int index2)
template<typename TypeHandler >
int	SpaceUsedExcludingSelf () const
template<typename TypeHandler >
TypeHandler::Type *	AddFromCleared ()
template<typename TypeHandler >
void	AddAllocated (typename TypeHandler::Type *value)
template<typename TypeHandler >
TypeHandler::Type *	ReleaseLast ()
int	ClearedCount () const
template<typename TypeHandler >
void	AddCleared (typename TypeHandler::Type *value)
template<typename TypeHandler >
TypeHandler::Type *	ReleaseCleared ()

Private Member Functions
	GOOGLE_DISALLOW_EVIL_CONSTRUCTORS (RepeatedPtrFieldBase)

Static Private Member Functions
template<typename TypeHandler >
static TypeHandler::Type *	cast (void *element)
template<typename TypeHandler >
static const TypeHandler::Type *	cast (const void *element)

Private Attributes
void **	elements_
int	current_size_
int	allocated_size_
int	total_size_

Static Private Attributes
static const int	kInitialSize = 0

Friends
class	GeneratedMessageReflection
class	ExtensionSet

Constructor & Destructor Documentation

google::protobuf::internal::RepeatedPtrFieldBase::RepeatedPtrFieldBase ( )

inlineprotected

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

Member Function Documentation

template<typename TypeHandler >

TypeHandler::Type * google::protobuf::internal::RepeatedPtrFieldBase::Add ( )

inlineprotected

 {
 if (current_size_ < allocated_size_) {
 return cast<TypeHandler>(elements_[current_size_++]);
 }
 if (allocated_size_ == total_size_) Reserve(total_size_ + 1);
 typename TypeHandler::Type* result = TypeHandler::New();
 ++allocated_size_;
 elements_[current_size_++] = result;
 return result;
}

Here is the call graph for this function:

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::AddAllocated ( typename TypeHandler::Type *  value )

protected

 {
 // Make room for the new pointer.
 if (current_size_ == total_size_) {
 // The array is completely full with no cleared objects, so grow it.
 Reserve(total_size_ + 1);
 ++allocated_size_;
 } else if (allocated_size_ == total_size_) {
 // There is no more space in the pointer array because it contains some
 // cleared objects awaiting reuse. We don't want to grow the array in this
 // case because otherwise a loop calling AddAllocated() followed by Clear()
 // would leak memory.
 TypeHandler::Delete(cast<TypeHandler>(elements_[current_size_]));
 } else if (current_size_ < allocated_size_) {
 // We have some cleared objects. We don't care about their order, so we
 // can just move the first one to the end to make space.
 elements_[allocated_size_] = elements_[current_size_];
 ++allocated_size_;
 } else {
 // There are no cleared objects.
 ++allocated_size_;
 }

 elements_[current_size_++] = value;
}

Here is the call graph for this function:

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::AddCleared ( typename TypeHandler::Type *  value )

inlineprotected

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

Here is the call graph for this function:

template<typename TypeHandler >

TypeHandler::Type * google::protobuf::internal::RepeatedPtrFieldBase::AddFromCleared ( )

inlineprotected

 {
 if (current_size_ < allocated_size_) {
 return cast<TypeHandler>(elements_[current_size_++]);
 } else {
 return NULL;
 }
}

int google::protobuf::internal::RepeatedPtrFieldBase::Capacity ( ) const

inlineprotected

 {
 return total_size_;
}

template<typename TypeHandler >

static TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::cast ( void *  element )

inlinestaticprivate

 {
 return reinterpret_cast<typename TypeHandler::Type*>(element);
 }

template<typename TypeHandler >

static const TypeHandler::Type* google::protobuf::internal::RepeatedPtrFieldBase::cast ( const void *  element )

inlinestaticprivate

 {
 return reinterpret_cast<const typename TypeHandler::Type*>(element);
 }

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::Clear ( )

protected

 {
 for (int i = 0; i < current_size_; i++) {
 TypeHandler::Clear(cast<TypeHandler>(elements_[i]));
 }
 current_size_ = 0;
}

int google::protobuf::internal::RepeatedPtrFieldBase::ClearedCount ( ) const

inlineprotected

 {
 return allocated_size_ - current_size_;
}

void google::protobuf::internal::RepeatedPtrFieldBase::CloseGap ( int  start, int  num  )

inlineprotected

 {
 // Close up a gap of "num" elements starting at offset "start".
 for (int i = start + num; i < allocated_size_; ++i)
 elements_[i - num] = elements_[i];
 current_size_ -= num;
 allocated_size_ -= num;
 }

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::CopyFrom ( const RepeatedPtrFieldBase &  other )

inlineprotected

 {
 if (&other == this) return;
 RepeatedPtrFieldBase::Clear<TypeHandler>();
 RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
}

template<typename TypeHandler >

const TypeHandler::Type *const * google::protobuf::internal::RepeatedPtrFieldBase::data ( ) const

inlineprotected

 {
 // TODO(kenton): Breaks C++ aliasing rules. We should probably remove this
 // method entirely.
 return reinterpret_cast<const typename TypeHandler::Type* const*>(elements_);
}

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::Destroy ( )

protected

 {
 for (int i = 0; i < allocated_size_; i++) {
 TypeHandler::Delete(cast<TypeHandler>(elements_[i]));
 }
 delete [] elements_;
}

bool google::protobuf::internal::RepeatedPtrFieldBase::empty ( ) const

inlineprotected

 {
 return current_size_ == 0;
}

template<typename TypeHandler >

const TypeHandler::Type & google::protobuf::internal::RepeatedPtrFieldBase::Get ( int  index ) const

inlineprotected

 {
 GOOGLE_DCHECK_GE(index, 0);
 GOOGLE_DCHECK_LT(index, size());
 return *cast<TypeHandler>(elements_[index]);
}

Here is the call graph for this function:

google::protobuf::internal::RepeatedPtrFieldBase::GOOGLE_DISALLOW_EVIL_CONSTRUCTORS ( RepeatedPtrFieldBase  )

private

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::MergeFrom ( const RepeatedPtrFieldBase &  other )

inlineprotected

 {
 GOOGLE_CHECK_NE(&other, this);
 Reserve(current_size_ + other.current_size_);
 for (int i = 0; i < other.current_size_; i++) {
 TypeHandler::Merge(other.template Get<TypeHandler>(i), Add<TypeHandler>());
 }
}

Here is the call graph for this function:

template<typename TypeHandler >

TypeHandler::Type * google::protobuf::internal::RepeatedPtrFieldBase::Mutable ( int  index )

inlineprotected

 {
 GOOGLE_DCHECK_GE(index, 0);
 GOOGLE_DCHECK_LT(index, size());
 return cast<TypeHandler>(elements_[index]);
}

Here is the call graph for this function:

template<typename TypeHandler >

TypeHandler::Type ** google::protobuf::internal::RepeatedPtrFieldBase::mutable_data ( )

inlineprotected

 {
 // TODO(kenton): Breaks C++ aliasing rules. We should probably remove this
 // method entirely.
 return reinterpret_cast<typename TypeHandler::Type**>(elements_);
}

void *const * google::protobuf::internal::RepeatedPtrFieldBase::raw_data ( ) const

inlineprotected

 {
 return elements_;
}

void ** google::protobuf::internal::RepeatedPtrFieldBase::raw_mutable_data ( ) const

inlineprotected

 {
 return elements_;
}

template<typename TypeHandler >

TypeHandler::Type * google::protobuf::internal::RepeatedPtrFieldBase::ReleaseCleared ( )

inlineprotected

 {
 GOOGLE_DCHECK_GT(allocated_size_, current_size_);
 return cast<TypeHandler>(elements_[--allocated_size_]);
}

template<typename TypeHandler >

TypeHandler::Type * google::protobuf::internal::RepeatedPtrFieldBase::ReleaseLast ( )

inlineprotected

 {
 GOOGLE_DCHECK_GT(current_size_, 0);
 typename TypeHandler::Type* result =
 cast<TypeHandler>(elements_[--current_size_]);
 --allocated_size_;
 if (current_size_ < allocated_size_) {
 // There are cleared elements on the end; replace the removed element
 // with the last allocated element.
 elements_[current_size_] = elements_[allocated_size_];
 }
 return result;
}

template<typename TypeHandler >

void google::protobuf::internal::RepeatedPtrFieldBase::RemoveLast ( )

inlineprotected

 {
 GOOGLE_DCHECK_GT(current_size_, 0);
 TypeHandler::Clear(cast<TypeHandler>(elements_[--current_size_]));
}

void google::protobuf::internal::RepeatedPtrFieldBase::Reserve ( int  new_size )

protected

Here is the caller graph for this function:

int google::protobuf::internal::RepeatedPtrFieldBase::size ( ) const

inlineprotected

 {
 return current_size_;
}

Here is the caller graph for this function:

template<typename TypeHandler >

int google::protobuf::internal::RepeatedPtrFieldBase::SpaceUsedExcludingSelf ( ) const

inlineprotected

 {
 int allocated_bytes =
 (elements_ != NULL) ? total_size_ * sizeof(elements_[0]) : 0;
 for (int i = 0; i < allocated_size_; ++i) {
 allocated_bytes += TypeHandler::SpaceUsed(*cast<TypeHandler>(elements_[i]));
 }
 return allocated_bytes;
}

void google::protobuf::internal::RepeatedPtrFieldBase::Swap ( RepeatedPtrFieldBase *  other )

protected

void google::protobuf::internal::RepeatedPtrFieldBase::SwapElements ( int  index1, int  index2  )

inlineprotected

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

Friends And Related Function Documentation

friend class ExtensionSet

friend

friend class GeneratedMessageReflection

friend

Member Data Documentation

int google::protobuf::internal::RepeatedPtrFieldBase::allocated_size_

private

int google::protobuf::internal::RepeatedPtrFieldBase::current_size_

private

void** google::protobuf::internal::RepeatedPtrFieldBase::elements_

private

const int google::protobuf::internal::RepeatedPtrFieldBase::kInitialSize = 0

staticprivate

int google::protobuf::internal::RepeatedPtrFieldBase::total_size_

private

---

The documentation for this class was generated from the following file:

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