Choreonoid  1.5
Public Types | Public Member Functions | List of all members
cnoid::SgVectorArray< T, Alloc > Class Template Reference

#include <SceneDrawables.h>

Inheritance diagram for cnoid::SgVectorArray< T, Alloc >:
cnoid::SgObject cnoid::Referenced

Public Types

typedef Container::iterator iterator
 
typedef Container::const_iterator const_iterator
 
typedef Container::size_type size_type
 
typedef Container::value_type value_type
 
typedef Container::reference reference
 
typedef Container::const_reference const_reference
 
typedef Container::pointer pointer
 
typedef Container::const_pointer const_pointer
 
typedef T::Scalar Scalar
 
- Public Types inherited from cnoid::SgObject
typedef std::set< SgObject * > ParentContainer
 
typedef ParentContainer::iterator parentIter
 
typedef ParentContainer::const_iterator const_parentIter
 

Public Member Functions

 SgVectorArray ()
 
 SgVectorArray (size_t size)
 
 SgVectorArray (const std::vector< T > &org)
 
template<class Element >
 SgVectorArray (const std::vector< Element > &org)
 
 SgVectorArray (const SgVectorArray &org)
 
virtual SgObjectclone (SgCloneMap &cloneMap) const
 
SgVectorArray< T > & operator= (const SgVectorArray< T > &rhs)
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
size_type size () const
 
void resize (size_type s)
 
void resize (size_type s, const T &v)
 
bool empty () const
 
void reserve (size_type s)
 
T & operator[] (size_type i)
 
const T & operator[] (size_type i) const
 
T & at (size_type i)
 
const T & at (size_type i) const
 
T & front ()
 
const T & front () const
 
T & back ()
 
const T & back () const
 
Scalardata ()
 
const Scalardata () const
 
void push_back (const T &v)
 
void pop_back ()
 
iterator erase (iterator p)
 
iterator erase (iterator first, iterator last)
 
void clear ()
 
- Public Member Functions inherited from cnoid::SgObject
const std::string & name () const
 
void setName (const std::string &name)
 
virtual int numChildObjects () const
 
virtual SgObjectchildObject (int index)
 
SignalProxy< void(const SgUpdate &update)> sigUpdated ()
 
void notifyUpdate (SgUpdate &update)
 
void notifyUpdate (int action=SgUpdate::MODIFIED)
 
void addParent (SgObject *parent, bool doNotify=false)
 
void removeParent (SgObject *parent)
 
int numParents () const
 
bool hasParents () const
 
const_parentIter parentBegin () const
 
const_parentIter parentEnd () const
 
SignalProxy< void(bool on)> sigGraphConnection ()
 
- Public Member Functions inherited from cnoid::Referenced
virtual ~Referenced ()
 
void addRef ()
 
void releaseRef ()
 

Additional Inherited Members

- Protected Member Functions inherited from cnoid::SgObject
 SgObject ()
 
 SgObject (const SgObject &org)
 
virtual void onUpdated (SgUpdate &update)
 
- Protected Member Functions inherited from cnoid::Referenced
 Referenced ()
 
 Referenced (const Referenced &org)
 
int refCount () const
 

Member Typedef Documentation

◆ const_iterator

template<class T, class Alloc = std::allocator<T>>
typedef Container::const_iterator cnoid::SgVectorArray< T, Alloc >::const_iterator

◆ const_pointer

template<class T, class Alloc = std::allocator<T>>
typedef Container::const_pointer cnoid::SgVectorArray< T, Alloc >::const_pointer

◆ const_reference

template<class T, class Alloc = std::allocator<T>>
typedef Container::const_reference cnoid::SgVectorArray< T, Alloc >::const_reference

◆ iterator

template<class T, class Alloc = std::allocator<T>>
typedef Container::iterator cnoid::SgVectorArray< T, Alloc >::iterator

◆ pointer

template<class T, class Alloc = std::allocator<T>>
typedef Container::pointer cnoid::SgVectorArray< T, Alloc >::pointer

◆ reference

template<class T, class Alloc = std::allocator<T>>
typedef Container::reference cnoid::SgVectorArray< T, Alloc >::reference

◆ Scalar

template<class T, class Alloc = std::allocator<T>>
typedef T::Scalar cnoid::SgVectorArray< T, Alloc >::Scalar

◆ size_type

template<class T, class Alloc = std::allocator<T>>
typedef Container::size_type cnoid::SgVectorArray< T, Alloc >::size_type

◆ value_type

template<class T, class Alloc = std::allocator<T>>
typedef Container::value_type cnoid::SgVectorArray< T, Alloc >::value_type

Constructor & Destructor Documentation

◆ SgVectorArray() [1/5]

template<class T, class Alloc = std::allocator<T>>
cnoid::SgVectorArray< T, Alloc >::SgVectorArray ( )
inline

◆ SgVectorArray() [2/5]

template<class T, class Alloc = std::allocator<T>>
cnoid::SgVectorArray< T, Alloc >::SgVectorArray ( size_t  size)
inline

◆ SgVectorArray() [3/5]

template<class T, class Alloc = std::allocator<T>>
cnoid::SgVectorArray< T, Alloc >::SgVectorArray ( const std::vector< T > &  org)
inline

◆ SgVectorArray() [4/5]

template<class T, class Alloc = std::allocator<T>>
template<class Element >
cnoid::SgVectorArray< T, Alloc >::SgVectorArray ( const std::vector< Element > &  org)
inline

◆ SgVectorArray() [5/5]

template<class T, class Alloc = std::allocator<T>>
cnoid::SgVectorArray< T, Alloc >::SgVectorArray ( const SgVectorArray< T, Alloc > &  org)
inline

Member Function Documentation

◆ at() [1/2]

template<class T, class Alloc = std::allocator<T>>
T& cnoid::SgVectorArray< T, Alloc >::at ( size_type  i)
inline

◆ at() [2/2]

template<class T, class Alloc = std::allocator<T>>
const T& cnoid::SgVectorArray< T, Alloc >::at ( size_type  i) const
inline

◆ back() [1/2]

template<class T, class Alloc = std::allocator<T>>
T& cnoid::SgVectorArray< T, Alloc >::back ( )
inline

◆ back() [2/2]

template<class T, class Alloc = std::allocator<T>>
const T& cnoid::SgVectorArray< T, Alloc >::back ( ) const
inline

◆ begin() [1/2]

template<class T, class Alloc = std::allocator<T>>
iterator cnoid::SgVectorArray< T, Alloc >::begin ( )
inline

◆ begin() [2/2]

template<class T, class Alloc = std::allocator<T>>
const_iterator cnoid::SgVectorArray< T, Alloc >::begin ( ) const
inline

◆ clear()

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::clear ( )
inline

◆ clone()

template<class T, class Alloc = std::allocator<T>>
virtual SgObject* cnoid::SgVectorArray< T, Alloc >::clone ( SgCloneMap cloneMap) const
inlinevirtual

Reimplemented from cnoid::SgObject.

◆ data() [1/2]

template<class T, class Alloc = std::allocator<T>>
Scalar* cnoid::SgVectorArray< T, Alloc >::data ( )
inline

◆ data() [2/2]

template<class T, class Alloc = std::allocator<T>>
const Scalar* cnoid::SgVectorArray< T, Alloc >::data ( ) const
inline

◆ empty()

template<class T, class Alloc = std::allocator<T>>
bool cnoid::SgVectorArray< T, Alloc >::empty ( ) const
inline

◆ end() [1/2]

template<class T, class Alloc = std::allocator<T>>
iterator cnoid::SgVectorArray< T, Alloc >::end ( )
inline

◆ end() [2/2]

template<class T, class Alloc = std::allocator<T>>
const_iterator cnoid::SgVectorArray< T, Alloc >::end ( ) const
inline

◆ erase() [1/2]

template<class T, class Alloc = std::allocator<T>>
iterator cnoid::SgVectorArray< T, Alloc >::erase ( iterator  p)
inline

◆ erase() [2/2]

template<class T, class Alloc = std::allocator<T>>
iterator cnoid::SgVectorArray< T, Alloc >::erase ( iterator  first,
iterator  last 
)
inline

◆ front() [1/2]

template<class T, class Alloc = std::allocator<T>>
T& cnoid::SgVectorArray< T, Alloc >::front ( )
inline

◆ front() [2/2]

template<class T, class Alloc = std::allocator<T>>
const T& cnoid::SgVectorArray< T, Alloc >::front ( ) const
inline

◆ operator=()

template<class T, class Alloc = std::allocator<T>>
SgVectorArray<T>& cnoid::SgVectorArray< T, Alloc >::operator= ( const SgVectorArray< T > &  rhs)
inline

◆ operator[]() [1/2]

template<class T, class Alloc = std::allocator<T>>
T& cnoid::SgVectorArray< T, Alloc >::operator[] ( size_type  i)
inline

◆ operator[]() [2/2]

template<class T, class Alloc = std::allocator<T>>
const T& cnoid::SgVectorArray< T, Alloc >::operator[] ( size_type  i) const
inline

◆ pop_back()

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::pop_back ( )
inline

◆ push_back()

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::push_back ( const T &  v)
inline

◆ reserve()

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::reserve ( size_type  s)
inline

◆ resize() [1/2]

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::resize ( size_type  s)
inline

◆ resize() [2/2]

template<class T, class Alloc = std::allocator<T>>
void cnoid::SgVectorArray< T, Alloc >::resize ( size_type  s,
const T &  v 
)
inline

◆ size()

template<class T, class Alloc = std::allocator<T>>
size_type cnoid::SgVectorArray< T, Alloc >::size ( ) const
inline

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