class nape.dynamics.InteractionGroupList
Available on all platforms
Nape list of InteractionGroup type objects
*
* Internally this list is at present implemented as a linked list with
* object pooled nodes and iterators with various fast paths made for
* standard access patterns (For instance accessing successive elements
* runs in constant time when using random access functions)
*
* Iteration of this list can be done in various ways, but the preferred
* way on all targets, is through use of the foreach function:
*
* list.foreach(function (obj) { * }); ** This method is inlined so that in haxe no closure will need to be created. *
* In AS3, a closure would need to be created in general, so for performance * reasons you 'may' choose to use iteration as follows: *
* for (var i:int = 0; i < list.length; i++) { * var obj:InteractionGroup = list.at(i); * } **
* NOTE: It is 'not' safe to modify a list whilst iterating over it. * If you wish to remove elements during an iteration you should use the * filter method, for example: *
* list.filter(function (obj) { * // operate on object. * // ... * return (false if you want object to be removed); * }); **
* In AS3, if you wish to avoid a closure generation, you can perform such * an iteration in a safe manner as follows: *
* var i:int = 0; * while (i < list.length) { * var obj:InteractionGroup = list.at(i); * // operate on object. * // ... * if (should remove obj) { * list.remove(obj); * continue; * } * else i++; * } ** Or if you are always clearing the list entirely you could write: *
* while (!list.empty()) { * var obj:InteractionGroup = list.pop(); * // operate on object. * // ... * } *
Class Fields
static function fromArray(array:Array<InteractionGroup>):InteractionGroupList
Convert standard Array to Nape list. * *
array | The array to be converted * |
returns | An equivalent Nape list. * |
static function fromVector(vector:Vector<InteractionGroup>):InteractionGroupList
Convert flash.Vector to Nape list. * *
vector | The vector to be converted * |
returns | An equivalent Nape list. * |
Instance Fields
function add(obj:InteractionGroup):Bool
Insert element into list in most effecient way.
*
* This method will defer to either the push or unshift function
* depending on which is most effecient in the context.
*
* If order of elements is not important then you should always use
* this function to insert elements.
*
*
obj | The object to insert. * |
returns | True if object was successfuly inserted. * |
function at(index:Int):InteractionGroup
Random access to elements of list by index.
*
* Under normal circumstances, accessing succesive elements via this
* method will occur in constant time.
*
*
index | The index of the element in list to access. * |
returns | The element at the given index. * |
function copy(?deep:Bool = false):InteractionGroupList
Produce a possibly deep copy of list. * *
deep | If true, then each element will have its own copy * function called instead of simply having its * reference copied over. * |
returns | The copied list. |
function filter(lambda:InteractionGroup ->Bool):InteractionGroupList
Iterate over list filtering elements.
*
* The given function will be applied to each element, whenever the
* function returns false, the element will be removed from the list.
*
* Any exception thrown by the supplied function will be treat as a
* signal to halt iteration acting as a 'break' statement.
*
* This method is to be greatly preferred for filtering logic as
* it is otherwise unsafe to modify the list during an iteration.
*
* An example of using this method to clean up a list whilst performing
* actions on the elements.
*
* list.filter(function (obj) { * // perform clean up with obj * return false; // remove from list. * }); ** *
lambda | The function to apply to each argument, deciding if * element should be removed. * |
returns | A reference to 'this' list. * |
function foreach(lambda:InteractionGroup ->Void):InteractionGroupList
Iterate over list applying function.
*
* Any exception thrown by the supplied function will be treat as a
* signal to halt iteration acting as a 'break' statement.
*
* This method should be preferred to using standard haxe iteration
* as there will be no allocation of an iterator object.
*
* list.foreach(function (obj) { * if (ignoreobject(obj)) return; //acts as a 'continue' statement * if (haltiteration(obj)) throw "": //acts as a 'break' statement * }); ** *
lambda | The function to apply to each argument. * |
returns | A reference to 'this' list. * |
function has(obj:InteractionGroup):Bool
Check if element is already in the list * *
obj | The object to test. * |
returns | True if object is in the list. |
function iterator():InteractionGroupIterator
Return Haxe iterator for list.
*
* Use of this iterator, whilst stylistically better in Haxe should not
* be used, in preference for use of the foreach function which will
* not require allocation of an iterator object.
*
* Equally in AS3, the foreach method should be the preferred way to iterate.
function merge(xs:InteractionGroupList):Void
Merge given list into this one.
*
* The result is that this list will have all objects from the argument
* that were not already in the list inserted. You should make no
* assumption about the order of these insertions.
*
*
xs | The list to merge. * |
function pop():InteractionGroup
Pop element from back of list.
*
* If you are wanting to clear a list, whilst operating on its elements,
* consider use of the filter method instead.
*
*
returns | The element removed from list. * |
function push(obj:InteractionGroup):Bool
Push element to back of list.
*
* When the order of objects is not important, it is best to use the
* add() method instead.
*
*
obj | The object to insert. * |
returns | True if object was successively inserted. * |
function remove(obj:InteractionGroup):Bool
Remove element from list.
*
* This is a linear time operation.
*
*
obj | The object to remove * |
returns | True if object was removed from list. * |
function shift():InteractionGroup
Pop element from front of list.
*
* If you are wanting to clear a list, whilst operating on its elements,
* consider use of the filter method instead.
*
*
returns | The element removed from list. * |
function unshift(obj:InteractionGroup):Bool
Push element to front of list.
*
* When the order of objects is not important, it is best to use the
* add() method instead.
*
*
obj | The object to insert. * |
returns | True if object was successively inserted. * |