Changes Report

Release History

VersionDateDescription
0.1.02007-03-21


Release 0.1.0 - 2007-03-21

TypeChangesBy
fixFixed bugs in the immutable dynamic list implementation, in the contains, containsSlice, getEntry, isEmpty and slice methods.moya
addImplemented Serializable for all the concrete IList and IMap implementations.moya
addImplemented Cloneable for all the concrete IList and IMap implementations.moya
addAdded hashCode and equals implementations for all the concrete IList and IMap implementationsmoya
fixFixed bug in extensible linked list implementation which threw a null pointer exception on the second(but not the first!) call to the deleteLast method. Also ensured deleteLast and deleteFirst always throw a list index out of bounds exception if there are no elements.moya
fixFixed a common bug in the extensible binary tree map, extensible hash map and extensible reference hash map implementations which caused the update method to either hang with 100% CPU usage or throw an exceptionmoya
fixFixed bug in extensible linked hash map implementation which caused a mishap to be thrown on every call to the update methodmoya
addAdded a chained map default implementation which looks up the specified key in another map, hence a layer of maps can be created by creating a chained map default with the previous layer and setting it at the next layers' default.moya
addAdded a first attempt at separating out the tree map storage from the tree map implementation. The intent is to make it easier to implement tree maps based on different types of backing store and to reduce the duplication of code.moya
addAdded a generic toArray method which returns a plain object array.moya
updateUpdated the default action methods to pass the map which has requested the default value for the given key. This allows for better errors when sharing defaults between multiple map instances.moya
updateChanged the IList#toArray method to interact with generic types properly. It now requires an array of the correct runtime type so that a valid (not fixed to Object[ ] ) array can be returned.moya
addMigrating to Java 5 - add generics type information, annotated for overrides and suppressing warnings and covariant return typesmoya
removeRemoved the return value from the methods for removing all values from a list or map.moya
addAdded list default to complement the existing map default and add list specific default behaviour.moya
addAdded methods to remove all entries from a map or list.moya
addAdded an immutable dynamic list implementation, whose values are filled in on demand.moya
addAdded two mutable map implementations that are basically hash maps but each key is stored as a java.lang.ref.Reference, so keys can be reclaimed by the garbage collector under certain conditions.moya
addAdded a mutable m ap implementation that is backed by an array of hash code buckets, where the hash code buckets form an insertion order linked list.moya
addAdded an immutable map implementation that is backed by an array of hash code buckets, where the hash code buckets form an insertion order linked list.moya
addAdded simple keyList, mapletList and valueList tests.moya
addAdded a binary tree based extensible map.moya
updatefor immutability, updateability and extensibility respectively.moya
addWhooho! We now have default actions to unify the bevhaviours of lists and maps when keys are missing(i.e.moya
updatefor immutability, updateability and extensibility respectively.moya
addAdded a toArray to the List interface, to return the list as an array.moya
addAdded a removeFirst and removeLast methods to the List interface, for easier removeal of those elements.moya
addAdded a mapletList method to the Map interface, to completment the keyList and valueList methods.moya
updateUpdated API to support sharing backing store on user demand. This is to allow an API user to better manage the trade off between the use of store and performance.moya
addAdded an variable length single value immutable list implementation, which contains a variable quantity of the same object.moya
addAdded an immutable integer list implementation, whose values are a contiguous set of integers.moya
updateMoved all anonymous map iterator implementations to be either standard public or public static inner classes. This removes the automatic link to the parent class instance, potentially improving memory management.moya
addAdded an abstract map iterator implementation, to make it easier to implement. Where appropriate, all existing map iterators have been converted to use it.moya
addmethods to the Map interface, to allow easy access to all the keys or values in a Map.moya
addAdded an immutable list implementation, which is backed by a maplet.moya
addAdded an immutable list implementation, which is backed by a string.moya
addAdded an immutable list and map implementation, which are backed by an instance of their respective Java Collection types. These classes help to form a bridge between the Java Collections package and this one.moya
addAdded an immutable empty list implementation, with a static instance for normal use.moya
addAdded an immutable singleton list implementation, which is a list containing a single object.moya
addAdded methods to check if a list contains a slice, as a convenience for users. These methods compliment the existing containsKey methods.moya
addAdded a mutable list implementation, which is backed by a singly linked chain of objects.moya
addAdded an immutable list implementation, which is backed by a singly linked chain of objects.moya
addAdded a mutable list implementation that is backed by a single array of objects. This implementation is not yet thread-safe.moya
addinterface.moya
addAdded an immutable map implementation that is backed by a single array of maplet objects.moya
addmethod.moya
addAdded an immutable set implementation, which is backed by a single object array. This also adds an abstract set implementation.moya
addrelated problem. The existing map alerts have been repackaged accordingly.moya
fixFixed all implementations to throw correct alerts from t heir iterators and added a test for the shared store array list.moya
fixAll immutable Map implementations now copy there backing store, to ensure that references to it are not held outside the implementation.moya
addAdded an immutable list implementation, which is backed by a single object array. As part of this implementation I've also added an abstract immutable list implementation and another immutable list implementation which shares it's backing store.moya
addinterface. This should help to avoid complaints about choosing one based indexing for the primary methods.moya
addAdded abstract implementations for an immutable map and mutable map, to make it a little bit easier to implement the interfaces.moya
add. This implementation is not yet thread-safe.moya
add. This implementation is not yet thread-safe.moya
fixkeys and values might cause NullPointerExceptions or fail to be found correctly.moya
addinterface matching the equivalent insert methods.moya
addAdded an immutable map implementation that is backed by an array of hash code buckets, e.g. like any other HashMap.moya
addAdded an immutable map implementation that is backed by a two arrays, one containing all the names and the other all the matching values.moya
addAdded an immutable map implementation that is backed by a single array of alternate name-value objects.moya
addAdded initial mutable/immutable map API.moya