|
| | CMappedList () |
| |
| | CMappedList (const CMappedList< Idx, T > &arg_pm) |
| |
| virtual CMappedList< Idx, T > & | operator= (const CMappedList< Idx, T > &arg_rhs) |
| |
| virtual | ~CMappedList () |
| |
| bool | operator== (const CMappedList< Idx, T > &rhs) |
| |
| bool | operator!= (const CMappedList< Idx, T > &rhs) |
| |
| void | swap (CMappedList< Idx, T > &arg_swap_obj) |
| |
| virtual T * | create (const Idx &arg_idx, const bool insert_at_start=true) |
| |
| virtual T * | create (const Idx &arg_idx, const T &arg_t, const bool insert_at_start=true) |
| |
| virtual T * | insert (const Idx &arg_idx, T *arg_t, const bool insert_at_start=true) |
| |
| virtual T * | at (const std::size_t arg_idx) |
| |
| virtual T * | at (const Idx &arg_idx) |
| |
| virtual const Idx * | getIndexAt (const std::size_t arg_idx) const |
| |
| virtual int | getIndexNumericAt (const Idx &arg_idx) const |
| |
| virtual int | getIndexNumericAt (const T *const arg_node) const |
| |
| virtual const T * | at_const (const std::size_t arg_idx) const |
| |
| virtual const T * | at_const (const Idx &arg_idx) const |
| |
| virtual bool | erase (T *arg_t) |
| |
| virtual bool | erase (const Idx &arg_idx) |
| |
| virtual std::size_t | size () const |
| |
| virtual bool | empty () const |
| |
| virtual bool | clear () |
| |
| virtual T * | operator[] (const std::size_t arg_idx) |
| |
| iterator | begin () |
| |
|
const_iterator | begin () const |
| |
|
iterator | end () |
| |
|
const_iterator | end () const |
| |
| virtual bool | sort (const std::vector< Idx > &arg_order) |
| |
| virtual bool | sort_get_order (std::vector< Idx > &ret_order) const |
| |
| virtual bool | isSorted () const |
| |
template<typename Idx, typename T>
class sutil::CMappedList< Idx, T >
A linked list to allocate memory for objects and store them, allowing pointer access.
Also grants std::map-based access to members, indexed on some type.
Main use : Manage a single data store for memory that many must access.
When to use: (a) You want to store pointers to the contained objects and guarantee that the pointed-to memory doesn't change (Eg. Adding an element to a vector or a map might invalidate the contained objects's addresses) (b) You usage is. Access a contained object once, and then perform lots of operations on it. (c) You don't want to manage either map access or memory for contained objects (d) You want the leanest possible code that does the above
template<typename Idx, typename T >
| T * sutil::CMappedList< Idx, T >::create |
( |
const Idx & |
arg_idx, |
|
|
const bool |
insert_at_start = true |
|
) |
| |
|
virtual |
Example usage: first.assign (7,100); // 7 ints with value 100 second.assign (first.begin(),first.end()); // a copy of first ******************************* The mapped list specific methods
Creates an element, inserts an element into the list and returns the pointer
Reimplemented in sutil::CMappedTree< TIdx, TNode >, sutil::CMappedTree< std::string, scl::SRigidBodyDyn >, sutil::CMappedTree< std::string, scl::SRigidBody >, and sutil::CMappedTree< std::string, scl::SGraphicsChaiRigidBody >.
template<typename Idx, typename T>
| T * sutil::CMappedList< Idx, T >::create |
( |
const Idx & |
arg_idx, |
|
|
const T & |
arg_t, |
|
|
const bool |
insert_at_start = true |
|
) |
| |
|
virtual |
Copies the given element, inserts the copied element into the list and returns the pointer to the copied element.
By default inserts element at the start/begin() position. If specified, flag is false, inserts at the end of the list.
If size is zero, insert at start/end doesn't matter.
Reimplemented in sutil::CMappedTree< TIdx, TNode >, sutil::CMappedTree< std::string, scl::SRigidBodyDyn >, sutil::CMappedTree< std::string, scl::SRigidBody >, and sutil::CMappedTree< std::string, scl::SGraphicsChaiRigidBody >.
template<typename Idx, typename T >
Returns the numeric index at the given typed index in the linked list
NOTE : The index starts at 0. Returns -1 if node not found.
Returns the numeric index at the given typed index in the linked list
template<typename Idx, typename T>
Returns the numeric index at the given typed index in the linked list
NOTE : The index starts at 0. Returns -1 if node not found.
Returns the numeric index at the given typed index in the linked list
template<typename Idx, typename T>
| T * sutil::CMappedList< Idx, T >::insert |
( |
const Idx & |
arg_idx, |
|
|
T * |
arg_t, |
|
|
const bool |
insert_at_start = true |
|
) |
| |
|
virtual |
Inserts the given object into the list and returns the pointer to the copied element. NOTE : The recommended method is to use create. Else the object memory deallocation might be ambiguous. Remember that the mapped list "always" clears its own data.
By default inserts element at the start/begin() position. If specified, flag is false, inserts at the end of the list.
If size is zero, insert at start/end doesn't matter.
Reimplemented in sutil::CMappedTree< TIdx, TNode >, sutil::CMappedTree< std::string, scl::SRigidBodyDyn >, sutil::CMappedTree< std::string, scl::SRigidBody >, and sutil::CMappedTree< std::string, scl::SGraphicsChaiRigidBody >.
template<typename Idx, typename T >
Sorting related functions
Sorts the list so that iterator access matches the given vector's index. Ie. Given indices 0 to n in the vector, the begin() iterator will match 0, and the end() will appear after iterating over n.
Any create/erase/swap etc. function call will invalidate the sort ordering.
Sorting type : Insertion Sort.
1.8.6
