WorldPackets::Array< T, N > Class Template Reference

#include <PacketUtilities.h>

Public Member Functions
	Array ()
	Array (size_type limit)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
size_type	size () const
bool	empty () const
reference	operator[] (size_type i)
const_reference	operator[] (size_type i) const
void	resize (size_type newSize)
void	reserve (size_type newSize)
void	push_back (value_type const &value)
void	push_back (value_type &&value)

Private Types
typedef std::vector< T >	storage_type
typedef storage_type::value_type	value_type
typedef storage_type::size_type	size_type
typedef storage_type::reference	reference
typedef storage_type::const_reference	const_reference
typedef storage_type::iterator	iterator
typedef storage_type::const_iterator	const_iterator

Private Attributes
storage_type	_storage
size_type	_limit

Detailed Description

template<typename T, std::size_t N = 1000>
class WorldPackets::Array< T, N >

Utility class for automated prevention of loop counter spoofing in client packets

Member Typedef Documentation

template<typename T, std::size_t N = 1000>

typedef storage_type::const_iterator WorldPackets::Array< T, N >::const_iterator

private

template<typename T, std::size_t N = 1000>

typedef storage_type::const_reference WorldPackets::Array< T, N >::const_reference

private

template<typename T, std::size_t N = 1000>

typedef storage_type::iterator WorldPackets::Array< T, N >::iterator

private

template<typename T, std::size_t N = 1000>

typedef storage_type::reference WorldPackets::Array< T, N >::reference

private

template<typename T, std::size_t N = 1000>

typedef storage_type::size_type WorldPackets::Array< T, N >::size_type

private

template<typename T, std::size_t N = 1000>

typedef std::vector<T> WorldPackets::Array< T, N >::storage_type

private

template<typename T, std::size_t N = 1000>

typedef storage_type::value_type WorldPackets::Array< T, N >::value_type

private

Constructor & Destructor Documentation

template<typename T, std::size_t N = 1000>

WorldPackets::Array< T, N >::Array ( )

inline

: _limit(N) { }

template<typename T, std::size_t N = 1000>

WorldPackets::Array< T, N >::Array ( size_type  limit )

inline

: _limit(limit) { }

Member Function Documentation

template<typename T, std::size_t N = 1000>

iterator WorldPackets::Array< T, N >::begin ( )

inline

{ return _storage.begin(); }

Here is the caller graph for this function:

template<typename T, std::size_t N = 1000>

const_iterator WorldPackets::Array< T, N >::begin ( ) const

inline

{ return _storage.begin(); }

template<typename T, std::size_t N = 1000>

bool WorldPackets::Array< T, N >::empty ( ) const

inline

{ return _storage.empty(); }

Here is the caller graph for this function:

template<typename T, std::size_t N = 1000>

iterator WorldPackets::Array< T, N >::end ( )

inline

{ return _storage.end(); }

Here is the caller graph for this function:

template<typename T, std::size_t N = 1000>

const_iterator WorldPackets::Array< T, N >::end ( ) const

inline

{ return _storage.end(); }

template<typename T, std::size_t N = 1000>

reference WorldPackets::Array< T, N >::operator[] ( size_type  i )

inline

{ return _storage[i]; }

template<typename T, std::size_t N = 1000>

const_reference WorldPackets::Array< T, N >::operator[] ( size_type  i ) const

inline

{ return _storage[i]; }

template<typename T, std::size_t N = 1000>

void WorldPackets::Array< T, N >::push_back ( value_type const &  value )

inline

 {
 if (_storage.size() >= _limit)
 throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);

 _storage.push_back(value);
 }

template<typename T, std::size_t N = 1000>

void WorldPackets::Array< T, N >::push_back ( value_type &&  value )

inline

 {
 if (_storage.size() >= _limit)
 throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);

 _storage.push_back(std::forward<value_type>(value));
 }

template<typename T, std::size_t N = 1000>

void WorldPackets::Array< T, N >::reserve ( size_type  newSize )

inline

 {
 if (newSize > _limit)
 throw PacketArrayMaxCapacityException(newSize, _limit);

 _storage.reserve(newSize);
 }

template<typename T, std::size_t N = 1000>

void WorldPackets::Array< T, N >::resize ( size_type  newSize )

inline

 {
 if (newSize > _limit)
 throw PacketArrayMaxCapacityException(newSize, _limit);

 _storage.resize(newSize);
 }

template<typename T, std::size_t N = 1000>

size_type WorldPackets::Array< T, N >::size ( ) const

inline

{ return _storage.size(); }

Here is the caller graph for this function:

Member Data Documentation

template<typename T, std::size_t N = 1000>

size_type WorldPackets::Array< T, N >::_limit

private

template<typename T, std::size_t N = 1000>

storage_type WorldPackets::Array< T, N >::_storage

private

---

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

• src/server/game/Server/Packets/PacketUtilities.h