ITIVector< IntType, T, Alloc > Class Template Reference

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. More...

#include <int-type-indexed-vector.h>

Inheritance diagram for ITIVector< IntType, T, Alloc >:

List of all members.

Public Types

typedef std::vector< T, Alloc > ParentType

typedef ParentType::size_type size_type

typedef ParentType::allocator_type allocator_type

typedef ParentType::value_type value_type

typedef ParentType::reference reference

typedef ParentType::const_reference const_reference

typedef ParentType::pointer pointer

typedef ParentType::const_pointer const_pointer

typedef ParentType::iterator iterator

typedef ParentType::const_iterator const_iterator

typedef
ParentType::reverse_iterator reverse_iterator

typedef
ParentType::const_reverse_iterator const_reverse_iterator

Public Member Functions

ITIVector ()

ITIVector (const allocator_type &a)

ITIVector (size_type n, const value_type &v=value_type(), const allocator_type &a=allocator_type())

ITIVector (const ITIVector &x)

template<typename InputIteratorType>

ITIVector (InputIteratorType first, InputIteratorType last, const allocator_type &a=allocator_type())

~ITIVector ()

const ParentType & get () const

-- Accessors -------------------------------------------------------------- This const accessor is useful in defining the comparison operators below.

ParentType * mutable_get ()

The mutable accessor is useful when using auxiliar methods relying on vector parameters such as JoinUsing(), SplitStringUsing(), etc.

reference operator[] (IntType i)

-- Modified methods -------------------------------------------------------

const_reference operator[] (IntType i) const

reference at (IntType i)

const_reference at (IntType i) const

ITIVector & operator= (const ITIVector &x)

-- Pass-through methods to STL vector -------------------------------------

void assign (size_type n, const value_type &val)

template<typename InputIt>

void assign (InputIt f, InputIt l)

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

size_type size () const

size_type max_size () const

void resize (size_type new_size, value_type x=value_type())

size_type capacity () const

bool empty () const

void reserve (size_type n)

void push_back (const value_type &x)

void pop_back ()

void swap (ITIVector &x)

void clear ()

reference front ()

const_reference front () const

reference back ()

const_reference back () const

pointer data ()

const_pointer data () const

iterator erase (iterator pos)

iterator erase (iterator first, iterator last)

iterator insert (iterator pos, const value_type &x)

void insert (iterator pos, size_type n, const value_type &x)

template<typename IIt>

void insert (iterator pos, IIt first, IIt last)

Detailed Description

template<typename IntType, typename T, typename Alloc = std::allocator<T>>
class ITIVector< IntType, T, Alloc >

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. This file provides the ITIVector container that wraps around the STL vector. The wrapper restrict indexing to a pre-specified type-safe integer type or IntType (see base/int-type.h). It prevents accidental indexing by different "logical" integer-like types (e.g. another IntType) or native integer types. The wrapper is useful as C++ and the standard template library allows the user to mix "logical" integral indices that might have a different role.

The container can only be indexed by an instance of an IntType class, which can be declared as:

DEFINE_INT_TYPE(IntTypeName, IntTypeValueType);

where IntTypeName is the desired name for the "logical" integer-like type and the ValueType is a supported native integer type such as int or uint64 (see base/int-type.h for details).

The wrapper exposes all public methods of STL vector and behaves mostly as pass-through. The only method modified to ensure type-safety is the operator [] and the at() method.

EXAMPLES --------------------------------------------------------------------

DEFINE_INT_TYPE(PhysicalChildIndex, int32); ITIVector<PhysicalChildIndex, ChildStats*> vec;

PhysicalChildIndex physical_index; vec[physical_index] = ...; <-- index type match: compiles properly. vec.at(physical_index) = ...; <-- index type match: compiles properly.

int32 physical_index; vec[physical_index] = ...; <-- fails to compile. vec.at(physical_index) = ...; <-- fails to compile.

DEFINE_INT_TYPE(LogicalChildIndex, int32); int32 logical_index; vec[logical_index] = ...; <-- fails to compile. vec.at(logical_index) = ...; <-- fails to compile.

NB: Iterator arithmetic is not allowed as the iterators are not wrapped themselves. Therefore, the following caveat is possible: (vec.begin() + 0) = ...; STL vector ------------------------------------------------------------------

Definition at line 69 of file int-type-indexed-vector.h.