ArbiterList

Nape list of Arbiter 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:Arbiter = list.at(i);
}

list.filter(function (obj) {
// operate on object.
// ...
return (false if you want object to be removed);
});

var i:int = 0;
while (i < list.length) {
var obj:Arbiter = list.at(i);
// operate on object.
// ...
if (should remove obj) {
list.remove(obj);
continue;
}
else i++;
}

while (!list.empty()) {
var obj:Arbiter = list.pop();
// operate on object.
// ...
}

Static Members #

Convert standard Array to Nape list.

Instance Members #

@private

Length of list.

@private

@private

Check if element is already in the list

Random access to elements of list by index.

Under normal circumstances, accessing succesive elements via this method will occur in constant time.

Push element to back of list.

When the order of objects is not important, it is best to use the add() method instead.

Push element to front of list.

When the order of objects is not important, it is best to use the add() method instead.

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.

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.

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.

Remove element from list.

This is a linear time operation.

Clear the list, removing all elements.

Test if list is empty or not.

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.

Produce a possibly deep copy of list.

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.

@private

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 (ignore_object(obj)) return; //acts as a 'continue' statement
if (halt_iteration(obj)) throw "": //acts as a 'break' statement
});

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.
});

Construct a new list.

Private Members #