See: Description
| Interface | Description |
|---|---|
| Double2BooleanFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2BooleanMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2BooleanMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2BooleanSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2ByteFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ByteMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ByteMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ByteMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2ByteSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ByteSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2CharFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2CharMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2CharMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2CharMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2CharSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2CharSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2DoubleFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2DoubleMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2DoubleMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2DoubleMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2DoubleSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2DoubleSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2FloatFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2FloatMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2FloatMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2FloatSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2IntFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2IntMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2IntMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2IntMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2IntSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2IntSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2LongFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2LongMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2LongMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2LongMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2LongSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2LongSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Double2ObjectFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ObjectMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ObjectMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ObjectMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Double2ObjectSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ObjectSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Double2ReferenceFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ReferenceMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ReferenceMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ReferenceMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Double2ReferenceSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ReferenceSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Double2ShortFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ShortMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ShortMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Double2ShortSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| DoubleBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| DoubleBigList |
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleBigListIterator |
A type-specific
BigListIterator . |
| DoubleCollection |
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| DoubleComparator |
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| DoubleHash |
A type-specific
Hash interface. |
| DoubleHash.Strategy |
A type-specific hash strategy.
|
| DoubleIndirectPriorityQueue |
A type-specific
IndirectPriorityQueue . |
| DoubleIterable |
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| DoubleIterator |
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| DoubleList |
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleListIterator |
A type-specific bidirectional iterator that is also a
ListIterator . |
| DoublePriorityQueue |
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleSet |
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleSortedSet |
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleStack |
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class | Description |
|---|---|
| AbstractDouble2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2BooleanMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2BooleanSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2BooleanSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2ByteFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ByteMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ByteMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2ByteSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ByteSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2ByteSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2CharFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2CharMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2CharMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2CharSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2CharSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2CharSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2DoubleFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2DoubleMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2DoubleMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2DoubleSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2DoubleSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2DoubleSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2FloatMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2FloatSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2FloatSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2IntFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2IntMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2IntMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2IntSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2IntSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2IntSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2LongFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2LongMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2LongMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2LongSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2LongSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2LongSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ObjectMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ObjectMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2ObjectSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ObjectSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2ObjectSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ReferenceMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ReferenceMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2ReferenceSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ReferenceSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2ReferenceSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDouble2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ShortMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractDouble2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ShortSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractDouble2ShortSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractDoubleBidirectionalIterator |
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractDoubleBigList |
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractDoubleBigList.DoubleSubList |
A class implementing a sublist view.
|
| AbstractDoubleBigListIterator |
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractDoubleCollection |
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleComparator |
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractDoubleIterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractDoubleList |
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractDoubleList.DoubleSubList |
A class implementing a sublist view.
|
| AbstractDoubleListIterator |
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractDoublePriorityQueue |
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractDoubleSet |
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractDoubleSortedSet |
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| AbstractDoubleStack |
An abstract class providing basic methods for implementing a type-specific stack interface.
|
| Double2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2ByteArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ByteAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ByteFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2ByteFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2ByteFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2ByteFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2ByteFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2ByteLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ByteMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2ByteMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2ByteMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2ByteMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2ByteMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2ByteOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ByteOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ByteRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ByteSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2ByteSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2ByteSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2ByteSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2ByteSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2CharArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2CharAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2CharFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2CharFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2CharFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2CharFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2CharFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2CharLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2CharMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2CharMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2CharMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2CharMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2CharMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2CharOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2CharOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2CharRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2CharSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2CharSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2CharSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2CharSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2CharSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2DoubleArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2DoubleAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2DoubleFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2DoubleFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2DoubleFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2DoubleFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2DoubleFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2DoubleLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2DoubleMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2DoubleMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2DoubleMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2DoubleMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2DoubleMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2DoubleOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2DoubleOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2DoubleRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2DoubleSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2DoubleSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2DoubleSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2DoubleSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2DoubleSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2IntArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2IntAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2IntFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2IntFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2IntFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2IntFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2IntFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2IntLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2IntMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2IntMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2IntMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2IntMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2IntMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2IntOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2IntOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2IntRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2IntSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2IntSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2IntSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2IntSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2IntSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2LongArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2LongAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2LongFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2LongFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2LongFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2LongFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2LongFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2LongLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2LongMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2LongMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2LongMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2LongMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2LongMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2LongOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2LongOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2LongRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2LongSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2LongSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2LongSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2LongSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2LongSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Double2ObjectArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ObjectAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ObjectFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2ObjectFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Double2ObjectFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Double2ObjectFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Double2ObjectFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Double2ObjectLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ObjectMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2ObjectMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Double2ObjectMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Double2ObjectMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Double2ObjectMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Double2ObjectOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ObjectOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ObjectRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ObjectSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2ObjectSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Double2ObjectSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Double2ObjectSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Double2ObjectSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Double2ReferenceArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ReferenceAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ReferenceFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2ReferenceFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Double2ReferenceFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Double2ReferenceFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Double2ReferenceFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Double2ReferenceLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ReferenceMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2ReferenceMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Double2ReferenceMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Double2ReferenceMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Double2ReferenceMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Double2ReferenceOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ReferenceOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ReferenceRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ReferenceSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2ReferenceSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Double2ReferenceSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Double2ReferenceSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Double2ReferenceSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Double2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Double2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Double2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Double2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Double2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Double2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Double2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Double2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Double2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Double2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Double2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Double2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Double2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Double2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Double2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| DoubleArrayFIFOQueue |
A type-specific array-based FIFO queue, supporting also deque operations.
|
| DoubleArrayIndirectPriorityQueue |
A type-specific array-based semi-indirect priority queue.
|
| DoubleArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| DoubleArrayPriorityQueue |
A type-specific array-based priority queue.
|
| DoubleArrays |
A class providing static methods and objects that do useful things with type-specific arrays.
|
| DoubleArrays.ForkJoinQuickSort | |
| DoubleArrays.ForkJoinQuickSort2 | |
| DoubleArrays.ForkJoinQuickSortComp | |
| DoubleArrays.ForkJoinQuickSortIndirect | |
| DoubleArrays.Segment | |
| DoubleArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| DoubleAVLTreeSet |
A type-specific AVL tree set with a fast, small-footprint implementation.
|
| DoubleBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| DoubleBigArrays |
A class providing static methods and objects that do useful things with big arrays.
|
| DoubleBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| DoubleBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| DoubleBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| DoubleBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| DoubleBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| DoubleBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| DoubleBigLists.ListBigList |
A class exposing a list as a big list.
|
| DoubleBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| DoubleBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| DoubleBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| DoubleCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| DoubleCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| DoubleCollections.IterableCollection |
A collection wrapper class for iterables.
|
| DoubleCollections.SynchronizedCollection |
A synchronized wrapper class for collections.
|
| DoubleCollections.UnmodifiableCollection |
An unmodifiable wrapper class for collections.
|
| DoubleComparators |
A class providing static methods and objects that do useful things with comparators.
|
| DoubleComparators.NaturalImplicitComparator |
A type-specific comparator mimicking the natural order.
|
| DoubleComparators.OppositeComparator | |
| DoubleComparators.OppositeImplicitComparator |
A type-specific comparator mimicking the opposite of the natural order.
|
| DoubleHeapIndirectPriorityQueue |
A type-specific heap-based indirect priority queue.
|
| DoubleHeapPriorityQueue |
A type-specific heap-based priority queue.
|
| DoubleHeaps |
A class providing static methods and objects that do useful things with heaps.
|
| DoubleHeapSemiIndirectPriorityQueue |
A type-specific heap-based semi-indirect priority queue.
|
| DoubleIndirectHeaps |
A class providing static methods and objects that do useful things with indirect heaps.
|
| DoubleIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| DoubleIterators.ByteIteratorWrapper |
A wrapper promoting the results of a ByteIterator.
|
| DoubleIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| DoubleIterators.FloatIteratorWrapper |
A wrapper promoting the results of a FloatIterator.
|
| DoubleIterators.IntIteratorWrapper |
A wrapper promoting the results of an IntIterator.
|
| DoubleIterators.ShortIteratorWrapper |
A wrapper promoting the results of a ShortIterator.
|
| DoubleIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| DoubleIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| DoubleIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| DoubleLinkedOpenCustomHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| DoubleLinkedOpenHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| DoubleLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| DoubleLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| DoubleLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| DoubleLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| DoubleLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| DoubleLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| DoubleLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access lists.
|
| DoubleOpenCustomHashSet |
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| DoubleOpenHashBigSet |
A type-specific hash big set with with a fast, small-footprint implementation.
|
| DoubleOpenHashSet |
A type-specific hash set with with a fast, small-footprint implementation.
|
| DoublePriorityQueues |
A class providing static methods and objects that do useful things with type-specific priority queues.
|
| DoublePriorityQueues.SynchronizedPriorityQueue |
A synchronized wrapper class for priority queues.
|
| DoubleRBTreeSet |
A type-specific red-black tree set with a fast, small-footprint implementation.
|
| DoubleSemiIndirectHeaps |
A class providing static methods and objects that do useful things with semi-indirect heaps.
|
| DoubleSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| DoubleSets.EmptySet |
An immutable class representing the empty set and implementing a type-specific set interface.
|
| DoubleSets.Singleton |
An immutable class representing a type-specific singleton set.
|
| DoubleSets.SynchronizedSet |
A synchronized wrapper class for sets.
|
| DoubleSets.UnmodifiableSet |
An unmodifiable wrapper class for sets.
|
| DoubleSortedSets |
A class providing static methods and objects that do useful things with type-specific sorted sets.
|
| DoubleSortedSets.EmptySet |
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| DoubleSortedSets.Singleton |
A class representing a singleton sorted set.
|
| DoubleSortedSets.SynchronizedSortedSet |
A synchronized wrapper class for sorted sets.
|
| DoubleSortedSets.UnmodifiableSortedSet |
An unmodifiable wrapper class for sorted sets.
|
Provides type-specific classes for double elements or keys.
Copyright © 2019. All rights reserved.


Spy Kids * * * out of * * * * Starring: Carla Gugino, Antonio Banderas, Alex Vega, Daryl, Sabara, Alan Cumming, Teri Hatcher, Cheech Marin, Danny Trejo, Mike Judge, Tony Shalhoub. Directed by: Robert Rodriguez Rated: PG (mild violence)
After the genuinely repellent "family" comedy "See Spot Run"...I was starting to think that the good family movie genre was out. Alas "Spy Kids" opens and goes against all I just said, but it is the best family movie to come out in long time, and is the best time I had at the theaters so far this year. The young actors prove themselves worthwhile, and the adult actors are just as great.
Surprisingly from the man who directed violent movies such as "Desperado" and "From Dusk Till Dawn" there is barely any violence let alone blood or gore in this movie. Robert Rodriguez wrote, directed and produced this tale about two young kids Carmen and Juni Cortez who find out their parents (Carla Gugino, and Antonio Banderas) are international spies and have been kidnapped by an evil kids show host, who wants to take over the world. Of course the kids must take the action upon themselves and save their parents by using the nifty gadgets, spy equipment etc.
In the end the film is a rewarding experience worthy of multi viewings, and your kids and even yourself will find yourself loving this film. Young Alex Vega and Daryl Sabara (sister and brother characters) play Carmen and Juni Cortez, the two seem to be real life friends as they work great together and have a good onscreen chemistry. Carla Gugino (Snake Eyes) and Antonio Banderas (Desperado, Assassins) play the parents of the kids, and also have a surprising amount of strong chemistry between the two.
As for the supporting cast Alan Cumming (Spice World, and the current Josie and the Pussycats) plays the scheming bad guy and is a very good actor. He seems to be having fun as the bad guy, and some surprising information is given about him in the end. Teri Hatcher has a small role, and in her role she is deliciously diabolical and funny as well. Some other great cameos include many people from Rodriguez's earlier movies.
Rodriguez's cleverly written and witty script is that of a great one. His dialogue is snappy and comes quickly out of the actors/actresses's mouth. His plot is very easy for younger people to understand and follow, and has no sex, scatological humor, bloody/violence or even cussing. Only a mild amount of violence occurs in the film, and it's much nice to see this than some man falling out of a window with his pants off into dog poop.
"Spy Kids" is one of the funniest movies I've seen so far in the year 2001, and is the best kids movie so far. See it with your entire family, and even those who aren't fans of kiddy movies you might find yourself having a lot of fun with this one. A winner.
Reviewed by Brandon Herring (4-9-01) http://us.imdb.com/ReviewsBy?Brandon+Herring
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


This is the MySQL Ruby API written by Ruby. It provides the same functions for Ruby programs that the MySQL C API provides for C programs.
This program is under Ruby's license.
% ruby ./setup.rb % ruby ./test.rb hostname user passwd # ruby ./install.rb
% ruby ./setup.rb
This command find MySQL's UNIX domain socket. This is not needed for system that does not have UNIX domain socket such as Microsoft Windows.
% ruby ./test.rb hostname user passwd
test.rb should be invoked with three arguments that indicate the MySQL server hostname, and the username and password for a MySQL account that can create a database named "rubytest". An optional fourth argument is allowed, to specify a database name to use rather than "rubytest". The database should not already exist.
# ruby ./install.rb
This command install mysql.rb to standard library directory(Config::CONFIG["rubylibdir"]). If you want to copy to other directory, copy mysql.rb to appropriate directory.
example)
require "mysql" my = Mysql::new("host", "user", "passwd", "db") res = my.query("select * from tbl") res.each do |row| col1 = row[0] col2 = row[1] end
The names of methods provided by this module basically are the same as the names of the functions in the C API, except that the Ruby method names do not begin with a 'mysql_' prefix. For example, the Ruby query() method corresponds to the C API mysql_query() function. For details on the use of each Ruby method, see the descriptions of the corresponding C functions in the MySQL Reference Manual.
Some Ruby methods may be invoked under other names that serve as equivalent aliases, as noted below.
If an error occurs when a method executes, it raises a Mysql::Error exception.
MySQL class
return Mysql class object.
connect to mysqld and return Mysql class object.
quote string for insert, update.
return client version information.
unsupported.
set options. opt is available only Mysql::OPT_LOCAL_INFILE. if val is omitted or val is true value, LOAD DATA LOCAL INFILE query can be used.
same as Mysql::real_connect().
return number of affected rows.
change user.
unsupported.
close connection.
create database.
drop database.
same as C API mysql_dump_debug_info().
return error number.
return error message.
quote string for insert, update.
return number of field for last query.
return connection information.
return protocol version.
return server version information.
return query information. if no information, return nil.
last generated AUTO_INCREMENT-ed field's value.
kill thread for id.
return array of database name.
return Mysql::Result class object that indicate field information.
return Mysql::Result class object that indicate thread list on server.
return array of table name.
check that server is alive.
do query. If query return result, automatically invoke store_result() and return Mysql::Result object when query_with_result is true. If query do not return result, return nil.
If true, query() also invokes store_result() and returns a MysqlRes object. Default is true.
do query only. store_result() is not invoked.
flush server log or cache.
reload grant table.
select database.
shutdown server.
return server status.
return Mysql::Result class object.
return thread id of this connection.
return Mysql::Result class object.
query result class. MysqlRes is alias name for compatibility.
set current row position to offset line.
repeat fetch_row().
repeat fetch_hash().
return Mysql::Field class object.
return array of Mysql::Field class object.
return nth Mysql::Field class object.
return array of length of field value of current row.
return array of field value.
return hash of pair of field name and field value. if with_table is true, hash key is table+"."+fieldname.
set current row position to offset line.
return current row position.
call GC::start.
return number of fields.
return number of rows.
same as data_seek().
return current row position.
field information class. MysqlField is alias for compatibility.
field name.
table name.
default value.
type of field.
field length.
maximum length of field of result set.
flag.
number of decimal.
return hash. obj.hash['name'] == obj.name, obj.hash['type'] == obj.type, ...
MySQL error class. MysqlError is alias for compatibility.
error number.
error message.
TOMITA Masahiro<EMAIL_ADDRESS>http://www.tmtm.org


96; 12022 H.E.
Many have asked me about my tag thecsw that I have used for the past ten-ish years. I thought it would be nice to write up a quick summary of how it came to be, as it had many iterations and some arbitrary changes made to it.
First of all, it does not stand for The Computer Science Wizard, though it would be kinda cool if it did. Super corny and cheesy, just the way I like it. However, that’s something created after the fact.
I was in 7th grade, it was time to become a true gamer. What does a true gamer need? A nickname to go by. Especially in Minecraft multiplayer lobbies. My first one was MrSagindyk, which blows. Let’s think about this. What would be a good nickname? Ah yes,
CoolSmoothy
It’s perfect. I like smoothies, using a y instead of ie makes it look gangster and very new-blood tech. I’m also cool 😎 But wait! Not only am I cool, but I’m also the coolest one. Therefore, the only appropriate nickname for me is
TheCoolSmoothy
It’s perfect (x2). Time to set it everywhere, especially on my trusty Xbox 360 my parents got me for Christmas.
probably a couple of weeks later...
Dude, this blows. I forgot my password to my xbox account. It had my cool nickname, TheCoolSmoothy. I still want to use it but can’t restore my password. No worries, I’ll just create a new account with the same username. Oh wait, I can’t. All right, modify it a little bit but still make it look somehow cool, maybe mysterious...
TheCoolSmoothyW
I’m a genius. That W really brings it together. Doesn’t mean anything. At least I have a new xbox account now. Speaking of new accounts, I saw a cool poop emoji-shaped pillow on eBay; I kinda want it. Gotta make an ebay account with my username. Holdup, does it have a character limit? Hmmm
tcsw
It’s perfect (x3). I’ve been going by tcsw for many months after that. I think that was around the time I watched The Social Network by Aaron Sorkin. Remember that scene with Sean Parker, where he tells Mark to drop the “the”?
Well, I decided to do the exact opposite. Bring the “the” back, whole thecsw. It’s crispier. And there we have it,
thecsw
It’s perfect (x4). This tag I made up when I was 13 has stuck with me ever since. I have some pretty rivals that are too similar to my tag, such as: Commission on the Status of Women, The CW Network, and ChristianSingleWoman (actually squatted @thecsw on Twitter).
Here is to thecsw propelling forward and drilling through the Heavens! ◼


Ecosystem
Git-converted Projects
Scalability
- Linux kernel averaging 2-4 changes per hour continuously for the last 4 years
- Have used with repos up to 2.4 GB in size, but that's on the large size
git gc
on an 8GB project is quite slow
- Modularization of your project is key (submodules)
- A multi-GB file can cause Git to run out of memory while commiting it.


Sheffield Benefit Centre Handovers queue
| Description | Name & NINO | Date/time raised | Agent | Time left to clear | Handover type | Handover Status | Callback status | ||
|---|---|---|---|---|---|---|---|---|---|
|
Change in bank details / change of address |
Adam Brown |
27 February 2018 |
Imogen JohnsonNOT AVAILABLE 2 |
Expired |
1 |
Claim closure |
Paused |
First call pending |
|
|
Med 3 attached 22/02/18 – 22/03/18 – change of GP |
Ian Jackson |
27 February 2018 13:08 |
1 hr 10 mins |
7 |
Claim closure |
In progress |
Not requested |
||
|
FE attached 20 pages as listed below : |
Grace Harris |
27 February 2018 13:06 |
Imogen JohnsonNOT AVAILABLE 2 |
58mins |
7 |
New Claim | Not allocated |
First call pending |
|
|
Change of address |
Christine Dixon |
27 January 201811:09 |
Not applicable |
1hr 38mins |
7 |
Appointment confirmation | Not allocated |
Not requested |
|
|
Information attached as requested by Hyde BC: Mortgage details |
Ian Jackson |
27 February11:07 |
1hr 59mins |
7 |
Hardship | In progress |
Not requested |
||
|
FTA NJI **/**/** |
Christine Dixon |
27 February 201811:03 |
2hr 10mins |
7 |
Missing evidence | In progress |
Second call pending |
Handover description
{{ description }}
{{ customerName }}
{{ nino }}
{{ date }}{{time}}
{{ agentName }}
{% if agentName == "john smith" %}
NOT AVAILABLE
{% endif %}
{{ timeToClear }}
7
{{ handoverType }}
{{ handoverStatus }}
{{ callbackStatus }}


AddTriangle ( surface,v0,v1,v2 )
Parameters:
| surface - surface handle v0 - index number of first vertex of triangle v1 - index number of second vertex of triangle v2 - index number of third vertex of triangle |
Description:
| Adds a triangle to a surface and returns the triangle's index number,
starting from 0. The v0, v1 and v2 parameters are the index numbers of the vertices created using AddVertex. Depending on how the vertices are arranged, then the triangle will only be visible from a certain side. Imagine that a triangle's vertex points are like dot-to-dot pattern, each numbered v0, v1, v2. If these dots, starting from v0, through to V2, form a clockwise pattern relative to the viewer, then the triangle will be visible. If these dots form an anti-clockwise pattern relative to the viewer, then the triangle will not be visible. The reason for having one-sided triangles is that it reduces the amount of triangles that need to be rendered when one side faces the side of an object which won't be seen (such as the inside of a snooker ball). However, if you wish for a triangle to be two-sided, then you can either create two triangles, using the same set of vertex numbers for both but assigning them in opposite orders, or you can use CopyEntity and FlipMesh together. |
| None. |


{{process.scanned | number}}
scanned
scanned
{{process.name | uppercase}}
{{process.queue | number}} ({{getInQueuePercent(process.queuePercent)}}) In Queue


My academic journey started at COD (College of DuPage) in Glen Ellyn, IL. COD gave me the opportunity to explore my interests and develop my love for engineering. I got to represent COD at a catapult competition, as well as volunteer for Engineering Olympics and StemCON hosted by the college. Most importantly, I decided to join Society of Women Engineers Club where I was elected vice-president. This experience ended May 2017 when I graduated with an Associate Degree in Engineering Science, Honors.
My favorite place to study at COD campus was the Learning Commons where I could ask tutors for help. These tutors were not only professors but also other students and friends. This is when I decided to start working as a peer tutor myself and assisted other students to become more successful and independent learners. I supported professor's instructions in classrooms by discussing concepts with their students and offering hands on assistance during labs.
After graduating from COD, I was ready to continue my academic journey by pursuing a bachelor's degree. As you can imagine, getting an acceptance letter from IIT was a really exciting moment. Not only was I going to be an Illinois Tech Hawk, but I was also awarded three different scholarships. The journey was difficult, with countless hours of studying. During my two years at IIT, I managed to make it to Dean's List as an honor student and graduate with a Bachelor's Degree in Computer Engineering, May 2019.
Being fresh out of college, the job market is scary and insanely competitive. With a lot of hours spent researching and preparing, I managed to land a job at one of the world's most renown corporations, UPS. I loved data mining in school and I was thrilled to explore databases. I am currently working as a Plant Engineering Data Specialist at Hodgkins, IL.


I am Shishir Kurhade, a second-year student for the MS in Data Science program at Northeastern University, Boston. I have over 2 years of experience working in data science. I have a Bachelor's degree in Computer Science from the University of Pune. Recently, I worked as a Machine Learning Engineer co-op at Nanotronics Imaging, prototyping and developing deep learning driven computer vision/imaging algorithms for industrial process control. Previously, I was a Data Scientist at Mu Sigma, where I analyzed data for a Fortune 500 retail client as a part of their pricing analytics team, helping find insights and trends to maximize profits. I am currently looking for opportunities in Machine Learning/Data Science. Please feel free to get in touch with me for possible opportunities via email -<EMAIL_ADDRESS>Competencies:


Roulette
You are
You have
ether
Make a new bet
Type/number:
Even
Odd
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Value:
Bet
Current bets
#
Player
Type/number
Value
Outcome roulette number:
Launch


| up: ARG | index | Zimbu documentation |
|
A Flag that includes all following arguments. The argument values are available as a list of strings. For example, with this flag: ARG.StringList args = NEW("a", "args", [], "the list of arguments")These arguments can be used: prog --args one -two three prog -a one -two three And will result in ["one", "-two", "three"]. The flag cannot be used more than once, because it consumes all the remaining arguments.
|
PROC NEW(string shortName, string longName, list<string> default, string doc) @public
FUNC $get() list<string> @public
FUNC $value() list<string> @public
|
| Copyright 2009 Bram Moolenaar All Rights Reserved. |
| Licensed under the Apache License, Version 2.0. See the LICENSE file or obtain a copy at: http://www.apache.org/licenses/LICENSE-2.0 |


"The last time I saw Uncle Pinkee, he was at home making cherry pie!" Timmie exclaimed. "Are you sure you heard him, mom?"
... "Maybe the stinging stinging cherry bees murdered him for stealing their cherries or... or?!"
"Help! Help!!"
It sounds like Uncle Pinkee's in trouble! We gotta save him!


Math Books About I’m going to use this to catalog what Mathematics books I’ve been reading so that I can remember. Books I’m reading Books I’ve read


You have been temporarily blocked because you have been overusing OSM's geocoding service or because you have not provided sufficient identification of your application. This block will be automatically lifted after a while. Please take the time and adapt your scripts to reduce the number of requests and make sure that you send a valid UserAgent or Referer.
For more information, consult the usage policy for the OSM Nominatim server.


How to Build¶
The modules are build by the use of “gulp” tasks and deployed to the dist directory. When available a minified and a normal version of the modules are created. All modules have an UMD-style wrapper which supports the use of the modules with AMD-loaders (like requirejs), commonjs loaders and usage as globals.
Node.js is required to get the build process started, however the modules do not depend on Node.js at runtime. To install Node.js on your system, check this page:
https://nodejs.org/en/download/package-manager/
Clone the git repository to your working directory:
# git clone https://github.com/datenwelt/cargo-js.git
...
Change to the project directory:
# cd cargo-js
Install bower and gulp as global commands:
# npm install bower -G
...
# npm install gulp -G
Install the required node modules and library dependencies with npm and bower (this can take a while to finish):
# npm install
...
# bower install
...
Now start the build process by:
# gulp build
After the build process finished, the compiled sources are in the dist directory and can be used as depedency in your projects.
The documentation can be build using the sphinx documentation generator from http://www.sphinx-doc.org and the appropriate gulp task:
# gulp doc
The resulting HTML documentation can be found under the directory dist/documentation
.


Click the appropriate targets below to download the executables for different platforms and different compilers. Most of these platforms are provided by the SourceForge.net compiler farm.
Table 1. Ported CcDoc Executables Version Arch O/S exe exe.gz exe.zip Ported By Ported Onv08r41 Apple
MacOS X Joe Linoff
This supercedes Mike Braca's original port.2003/05/15 v08r26 ARM Acorn X XMay 2002 v08r41 DEC Alpha Debian Linux 3.0 Joe Linoff2004/09/29 v08r41 Sun Ultra-80 Solaris 8 Joe Linoff2004/09/29 v08r41 x86 Cygwin Joe Linoff 2004/09/29 v08r41 x86 Debian Linux 2.2 Joe Linoff2004/09/29 v08r41 x86 Linux 2.4.21-4 Joe Linoff 2004/09/29 v08r39 x86 OS/2 Warp X X Alex Samorukov,
Dmitry A.Steklenev2003/05/23 v08r41 x86
Redhat Linux 9.0
IBM WebSphereJoe Linoff 2004/09/29 v08r41 x86 Windows
(98,2k,Me,XP) Joe Linoff2004/09/29
Click the appropriate targets below to download the source or documentation archives.
Table 2. Documentation and Source Code DownloadsTarget SizeDescription ccdoc.man 17kThe ccdoc man page. It is automatically generated from the help.txt file. doc.tar.gz 1,444kThe documentation file. This includes the users guide and the web site pages.
src.tar.gz 1,737kThe source code and documentation.
Miscellaneous tools. These are tools that I have developed during my ccdoc work that may be of use to you.
Table 3. Miscellaneous Local ToolsTarget SizeDescription counter.pl 68kA perl script that generates a counter image for HTML. It is used by ccdoc as a cgi script to generate the counters on various ccdoc pages (including this one).
The generated image is an uncompressed GIF image. It can be used as a counter for an arbitrary number of pages because you can specify the name of the counter file. It is completely self contained so you don't need any extra executables or libraries. In addition you can specify the fg and bg colors, whether comma's are inserted and with a little editing, your fonts.
To get more information about this script visit http://ccdoc.sourceforge.net/cgi-bin/counter.pl?help.
dtree.pl 13k Generates directory trees from the command line. Useful for generating documentation.
make_issues.pl 23kGenerate HTML documentation for an issues page. It is what ccdoc uses for its issues pages.


Eventually you are able to get your head above the water, coughing and spitting. You grab a hold of a chink in the wall. After some time, the water settles and you are able to stand. You are unsure where you are, and you have no source of light.


public bool HttpQueryString::xlate ( string $ie , string $oe )
Converts the query string from the source encoding ie to the target encoding oe. Warning Don't use any character set that can contain NUL bytes like UTF-16. Note: This method requires ext/iconv to be enabled and loaded.
Returns TRUE on success or FALSE on failure.


Being More Terse¶
Ada is known for being more verbose than other languages because it prefers keywords over symbology. These techniques can help you compact your Ada text where you need it.
Expression Functions¶
function "-"(V : Vec3) return Vec3 is
begin
return (-V.X, -V.Y, -V.Z);
end "-";
Functions can return expressions without using a full begin
… end
section. Just wrap your expression in parentheses.
function "-"(V : Vec3) return Vec3 is (-V.X, -V.Y, -V.Z);
Don’t repeat parameter types¶
function Add (Left : Integer; Right : Integer)
return Integer;
If parameter types repeat, you can group them.
function Add (Left, Right : Integer)
return Integer;
Locally use packages¶
procedure Test_Is_Quoted (Op : in out TT.Operation'Class) is
begin
Op.Register;
Op.Assert (not Is_Quoted (Ada.Characters.Latin_1.Quotation & "some text"));
end Test_Is_Quoted;
Using packages locally doesn’t pollute your global namespace.
procedure Test_Is_Quoted (Op : in out TT.Operation'Class) is
use Ada.Characters.Latin_1;
begin
Op.Register;
Op.Assert (not Is_Quoted (Quotation & "some text"));
end Test_Is_Quoted; -- Visibility of Latin_1 ends here.
Abbreviate conversions functions¶
Toggles.Append(Ada.Strings.Unbounded.To_Unbounded_String("--verbose"));
Toggles.Append(Ada.Strings.Unbounded.To_Unbounded_String("--skip-errors"));
The usage of "+"
as a function to convert from String
to
Ada.Strings.Unbounded.Unbounded_String
is common:
function "+"(S : String) return String renames Ada.Strings.Unbounded.To_Unbounded_String;
Toggles.Append(+"--verbose");
Toggles.Append(+"--skip-errors");
Use default parameters¶
S : Spinner := Make (In_Place, 1);
Default parameters allow you to apply common parameter values.
– When this function signature is used… function Make (Style : Spinner_Style := In_Place; Ticks_Per_Move : Positive := 1) return Spinner;
S : Spinner := Make;
Rename functions with default parameters¶
S : String := Ada.Strings.Fixed.Trim (" this is a string ", Ada.Strings.Both);
You can rename
a function with bound default parameters.
function Strip(Input : String; Sides : Ada.Strings.Trim_End:= Ada.Strings.Both)
renames Ada.Strings.Fixed.Trim;
S : String := Strip (" this is a string ");
Locally define helper functions¶
procedure Test_Is_Quoted (Op : in out TT.Operation'Class) is
use Ada.Characters.Latin_1;
begin
Op.Register;
Op.Assert (not Is_Quoted(""));
Op.Assert (not Is_Quoted ("not quoted"));
end Test_Is_Quoted;
Using a locally defined helper function to simplify repeated local logic. Note that these local subprograms don’t pollute the global namespace.
procedure Test_Is_Quoted (Op : in out TT.Operation'Class) is
use Ada.Characters.Latin_1;
procedure Not_Quoted (S : String) is
begin
Op.Assert (not Is_Quoted(S));
end Not_Quoted;
begin
Op.Register;
Not_Quoted ("");
Not_Quoted ("not quoted");
end Test_Is_Quoted;
Use package renames within package body
¶
with Ada.Text_IO;
package body Hello_World is
procedure Greet is
begin
Ada.Text_IO.New_Line;
Ada.Text_IO.Put_Line ("Hello, world!");
Ada.Text_IO.New_Line;
end Greet;
end Hello_World;
Show indication of where subprograms come from while shortening the names used for them. Names inside package bodies won’t be visible.
with Ada.Text_IO;
package body Hello_World is
package AIO renames Ada.Text_IO;
procedure Greet is
begin
AIO.New_Line;
AIO.Put_Line ("Hello, world!");
AIO.New_Line;
end Greet;
end Hello_World;
Use a package at file scope¶
with Ada.Text_IO;
package body Hello_World is
procedure Greet is
begin
Ada.Text_IO.New_Line;
Ada.Text_IO.Put_Line ("Hello, world!");
Ada.Text_IO.New_Line;
end Greet;
end Hello_World;
Some packages provide well-recognizable subprograms and hence cannot be confused easily. When these symbols are used often, using the package at the file scope can cut down significantly on verboseness. You’re polluting the namespace heavily so this should be used judiciously.
with Ada.Text_IO; use Ada.Text_IO;
package body Hello_World is
procedure Greet is
begin
New_Line;
Put_Line ("Hello, world!");
New_Line;
end Greet;
end Hello_World;
Provide abstraction without introducing more code¶
You might not know how you want to use a subprogram, but still want to separate it from another one which could stand-in for it.
package RT.Debug is
procedure Print (Str : String) renames Ada.Text_IO.Put_Line;
end RT.Debug;
Rename complicated expressions¶
Sometimes you might have long complicated expressions, which you can rename, which assigns their value when the renaming occurs. This is not text substitution, so the initial value cannot be modified.
with Ada.Text_IO;
procedure Sample is
use Ada.Text_IO;
type Int_List is array (1 .. 10) of Integer;
Values : Int_List := (others => 0);
Index : Integer := 1;
First : Integer renames Values(Index);
Second : Integer renames Values(2);
begin
Put_Line (First'Image);
Put_Line (Second'Image);
New_Line;
First := 5;
Put_Line ("First changed to 5");
Put_Line (First'Image);
Put_Line (Second'Image);
New_Line;
Index := 2;
Put_Line ("Index changed to 2");
Put_Line (First'Image);
Put_Line (Second'Image);
New_Line;
First := 7;
Put_Line ("First changed to 7");
Put_Line (First'Image);
Put_Line (Second'Image);
end Sample;
Output:
0
0
First changed to 5
5
0
Index changed to 2
5
0
First changed to 7
7
0


Game Overview
Seconds Remaining:
Score: 0
Level: 1
See the game overview for playing tips and tricks.


Unknown state
Robot Code Build:
Connect
Auton Chooser:
No Autons Available
Selected
Auton
X
Select the Auton you want to run:
Powercell Count:
#
Vision Data:
Target
Distance
Angle 1
COMS
##in
##°
Is Alt Shot
Is At Speed
Climber:
Climber is Running
Shooter:
Shot Distance
Shooter Offset
Shooter Sensor Distance
##in
##in
bfhbfk
Connection
Login:
==== USB Connect ====
[<IP_ADDRESS>]
==== Radio Connect ====
[<IP_ADDRESS>]
==== Open Developer ====
Screen


--- layout: post title: Vertically challenged footers tags: [] status: publish type: post published: true meta: {} ---
Courtesy of Mr Zeldman, a hint to look at the ala web site where Bobby Van Der Sluis looks at different ways to display a footer that is consistently bottom aligned. He looks at the standards way of doing it, before looking at the workarounds for all those lovely browsers. The bottom line... finally a set of solutions for consistently bottom aligned footers, no matter what the length of your page or the height of your browser.


EnumTransform Class
Base transform class that implements an enumeration type. During serialization and deserialization it checks if value is not outside of accessible values and returns same string.
Methods
deserialize
-
serialized
Returns deserialized enumeration field.
Parameters:
-
serialized
NumberSerialized enumeration field (index).
Returns:
Deserialized enumeration field (name).
Returns null
or undefined
if serialized
has
one of these values.
deserialize
-
serialized
Returns deserialized enumeration field.
Parameters:
-
serialized
StringSerialized enumeration field (name).
Returns:
Deserialized enumeration field (name).
Returns null
or undefined
if serialized
has one of these values.
Properties
values
Array | Ember.Array | Object
public
Available choises of enumeration. It is required field in a derived class.
Example:
['Easy', 'Difficult', 'Hard']
{ Easy: 1, Difficult: 2, Hard: 3 }
values
Array | Ember.Array | Object
public
Available choises of enumeration. It is required field in a derived class.
Example:
['Easy', 'Difficult', 'Hard']
{ Easy: 1, Difficult: 2, Hard: 3 }


{% extends 'layout-lab-5-a-to-z.html' %} {% block pageTitle %} Treatment - Cervical cancer - NHS.UK {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
Treatment for cervical cancer depends on how far the cancer has spread.
As cancer treatments are often complex, hospitals use multidisciplinary teams (MDTs) to treat cervical cancer and tailor the treatment programme to the individual.
MDTs are made up of a number of different specialists who work together to make decisions about the best way to proceed with your treatment.
Your cancer team will recommend what they think the best treatment options are, but the final decision will be yours. In most cases, the recommendations will be:
Cervical cancer is often curable if it's diagnosed at an early stage.
When cervical cancer is not curable, it's often possible to slow its progression, prolong lifespan and relieve any associated symptoms, such as pain and vaginal bleeding. This is known as palliative care.
The different treatment options are discussed in more detail in the following sections.
This is where the cancerous cells are removed using a fine wire and an electrical current.
It's usually done under local anaesthetic (while you're awake but the area is numbed) and can be done at the same time as a colposcopy.
A cone-shaped area of abnormal tissue is removed during surgery. This is usually done under general anaesthetic (while you're asleep).
There are 3 main types of surgery for cervical cancer:
Pelvic exenteration is only offered when cervical cancer has come back.
A trachelectomy is usually only suitable if cervical cancer is diagnosed at a very early stage. It's usually offered to women who want to have children in the future.
During the procedure, the cervix and upper section of the vagina are removed, leaving the womb in place. Your womb will then be reattached to the lower section of your vagina.
It's usually done by keyhole surgery.
Lymph nodes (part of the lymphatic system, the body's waste-removal system) from your pelvis may also be removed.
Compared with a hysterectomy or pelvic exenteration, the advantage of this type of surgery is that your womb remains in place. This means you may still be able to have children.
However, it's important to be aware that the surgeons carrying out this operation cannot guarantee you will still be able to have children.
A stitch will be put in the bottom of your womb during the surgery. This is to help support and keep a baby in your womb in future pregnancies. If you do get pregnant after the operation, your baby will have to be delivered by caesarean section.
It's also usually recommended you wait 6 to 12 months after surgery before trying for a baby so your womb and vagina have time to heal.
Trachelectomy is a highly skilled procedure. It's only available at certain specialist centres in the UK, so it may not be offered in your area and you may need to travel to another city for treatment.
A hysterectomy is usually recommended for early cervical cancer. This may be followed by a course of radiotherapy to help prevent the cancer coming back.
Two types of hysterectomies are used to treat cervical cancer:
Short-term complications of a hysterectomy include infection, bleeding, blood clots and accidental injury to your ureter, bladder or rectum.
Although the risk of them is small, long-term complications can be troublesome. They include:
Because your womb is removed during a hysterectomy, you will not be able to have children.
If your ovaries are removed, it will also trigger the menopause if you have not already experienced it.
See complications of cervical cancer for more information about the menopause.
A pelvic exenteration is a major operation that's usually only recommended when cervical cancer comes back. It's offered if the cancer returns to the pelvis but has not spread beyond this area.
A pelvic exenteration involves 2 phases:
Following pelvic exenteration, it may be possible to reconstruct your vagina using skin and tissue taken from other parts of your body. This would mean you could still have sex after the procedure, although it may be several months until you feel well enough to do so.
Radiotherapy may be used on its own or in combination with surgery for early-stage cervical cancer. It may be combined with chemotherapy for advanced cervical cancer, where it can be used to control bleeding and pain.
Radiotherapy can be delivered either:
In most cases, a combination of internal and external radiotherapy will be used. A course of radiotherapy usually lasts about 5 to 8 weeks.
As well as destroying cancerous cells, radiotherapy can sometimes also harm healthy tissue. This means it can cause significant side effects many months, or even years, after treatment.
Brachytherapy aims to reduce harm to surrounding tissue by delivering the radiation as close as possible to the tumour, but it can still cause side effects.
However, the benefits of radiotherapy often tend to outweigh the risks. For some people, radiotherapy offers the only hope of getting rid of the cancer.
Side effects of radiotherapy are common and can include:
Most of these side effects will resolve within about 8 weeks of finishing treatment, although in some cases they can be permanent. It's also possible to develop side effects several months, or even years, after treatment has finished.
If infertility is a concern for you, it may be possible to surgically remove eggs from your ovaries before you have radiotherapy so they can be implanted in your womb at a later date. However, you may have to pay for this.
It may also be possible to prevent an early menopause by surgically removing your ovaries and replanting them outside the area of your pelvis that will be affected by radiation. This is called an ovarian transposition.
Your doctors can provide more information about the possible options for treating infertility and whether you're suitable for an ovarian transposition.
Chemotherapy can be combined with radiotherapy to try to cure cervical cancer, or it can be used as a sole treatment for advanced cancer to slow its progression and relieve symptoms (palliative chemotherapy).
Chemotherapy for cervical cancer usually involves using either a single chemotherapy drug, called cisplatin, or a combination of different chemotherapy drugs to kill the cancerous cells.
Chemotherapy is usually given straight into your vein using a drip. You will probably be seen as an outpatient so will be able to go home once you've received your dose.
As with radiotherapy, these medications can also damage healthy tissue. Side effects are therefore common and can include:
If you do lose your hair, it usually should grow back within 6 months of the completion of your course of chemotherapy.
Some types of chemotherapy medication can damage your kidneys so you may need to have regular blood tests to assess the health of your kidneys.
After you finish your treatment and the cancer has been removed, you'll need to attend regular appointments for testing. This will usually involve a physical examination of your vagina and cervix (if it hasn't been removed).
Because cervical cancer can return, these examinations will be used to look for signs of this happening. If the examination finds anything suspicious, a further biopsy can be done.
Follow-up appointments are usually recommended every 3 to 6 months for the first 2 years, and then every 6 to 12 months for a further 3 years.
Members of your MDT may include:
Page last reviewed: 8 August 2017
Next review due: 8 August 2020


For the last 10 years, Valour Enterprises has strived to become the best that they can be. Not just for their customers but more importantly for their employees. Taking multiple companies and turning them into one coheasive whole is no easy task but that is our mission, to make a creative and fun atmosphere that enriches our employee's lives so that they can provide the best service to their customers, regardless of what industry they are in.


See the 'tree-dummy.js' file for tree data.
You can check for custom events in the console.
You can see the tutorial
here
.
append on 'rowKey: 0'
remove at 'rowKey: 0'


Isoulation Factor
Infection Chance
Population
Size
Run
Time
Healthy
Infected
Dead
Recovered
Generation Graphs
State distribution over population per generation
Number of generations until consensus as a function of the population size
Avg consensus time as a function of the population size
Avg number of generation that all population infected as a function of the infection chance
Research conclusions
We wish to answer the following questions using the simulator:
- How the population size (N) is affecting the averge convergece time?
- How the infection chance (p) is affecting the averge convergece time?
- How the isolation factor (k) is affecting the averge convergece time?
To answer these questions, we used a simple model based on the "game of life" calculation model. We implemented each agent to perform two things in each generation.
First, randomly pick a location between the 8 nearby cells and itself and try to move to there. If another agent is located at this location then stay in the same location.
Second, if the agent is infected (red), look at each of the nearby cells. If an agent is allocated in them, change it's status to infected as well.
We repeat this process until all the population is infected. This whole process is repeated multiple times to get a good mean value reducing the stochastic noise of the system.
Afterwards, the averge values are calculated and the whole process starts with different population size.
We repeat the simulation with varying population size, infection chance (p) and isolation factor (k) in ascending order.
The isolation factor is implemented by blocking the possible directions of infection represented by neighboring cells. Starting at the upper cell at k=1, moving in a clock-wise rotation, blocking more cells from the abilty to ifect.
For each k value a txt file is saved automatically summarizing the results.
An optional parameter L delaying the time when the isolation kicks in is also implemented
Finally, when the simulation is over the results are saved as a list of matrices of (population size, infection chance).
We also implemented, for future analysis which is beyond the scope of the exercise, possibilities of death and recovery that can be manipulated by the user.
The two main objects of the simulation are 'grid' and 'population'. The grid serving as the environment for our the interactions of its misfortunate inhabitants.
Population object responsible for keeping track of the inhabitants and their changing locations and states which are crucial for the epidemic simulation.
We would also like to point out an algorithmic achievement in the implementation of the infection funciton.
In each iteration, next to be infected individuals are found with complexity of O(1) and are infected during the runtime of the same iteration.
In total the computational complexity sums to O(9*N) ~ O(N), where N is the population size, instead of being O(M^2), where M is the grid length.
Assuming that M^2 >> N it is easy to see the benefit of such approach.
Based on the data from the simulation, we used the min least squres method on the function familiy:
f(s,p) = a + b * s + c * p
.
We picked this function familiy to get a fair approximation on one hand but a simple model on the other hand. Indeed, running the Python code on the results included
here
provides:
-
k = 0 : 199.56 - 0.36 * s - 0.36 * p | R^2 = 0.023
-
k = 1 : 243.43 - 0.92 * s - 0.98 * p | R^2 = 0.75
-
k = 2 : 307.52 - 1.15 * s - 1.27 * p | R^2 = 0.67
-
k = 3 : 267.78 - 1.05 * s - 1.01 * p | R^2 = 0.67
-
k = 4 : 307.52 - 1.15 * s - 1.27 * p | R^2 = 0.69
-
k = 5 : 323.55 - 1.16 * s - 1.34 * p | R^2 = 0.72
-
k = 6 : 439.48 - 1.60 * s - 1.99 * p | R^2 = 0.71
-
k = 7 : 627.76 - 2.26 * s - 3.07 * p | R^2 = 0.66
In addition, we can understand how effective the isulation factor by computing the integral of each two functions. The results shown in the following graph:
We fit the results with the function family:
f(k) = a + b * x + c * x ^ 2
,
getting:
f(k) = 78 - 49.5 * k + 19.8 * k ^ 2
with
R^2 = 0.963
.
We can conculde that the isulation factors is increasing the time taking the whole population to be infected because the graph is non-negative which indicates as isolation factor increasing the mean time for conversation is increasing as well.
By qualitative analysis of the two graphs above it is apparent that when at k equals 5 there is a significant change of the graphs behavior.
This leads us to the cautious conclusion that k=5 is the threshold isolation factor needed to control a epidemic in this simplified world.
As of the effect of the population size N, it easly seen from looking at runtime graphs with various initial parameters that not the sheer size but the density of the population has a key role in the infection rates.
This phenomenon is expected and can be observed in the real world, where densely populated citites serve as outbreak hubs on a national level.
Observing the effect of the infection chance p on different sizes of population we noted that the convergece time increased in a roughly linear fashion and there wasn't any threshold infection we could point out, below the convergece times increased substantially.
It is worth noting that as expected L shortenes the convergece times, especially for high K's, making the isolation practically irrelevant when the L is large enough.


You are trying to connect over HTTPS. To secure an instance, you must provide your own valid TLS certificate
for production operations.A self-signed certificate is included within Fledge, and you will need to configure
your browser to accept it as valid. To do this, click this link and in that page accept the certificate.


WITNESS LIST Prompt Payment of Health Care Providers Committee October 18, 2002 - 9:30A Medical Malpractice Liability Insur ON: Calvo, Cheye Committee Director (National Conference of State Legislatures), Washington, DC Carroll, Mary Nursing Home Administrator (Golden Age Home), Lockhart, TX Chalberg, Allan Nursing Home Owner / Operator (Anderson Nursing Center, Grand Saline), Austin, TX Duffner, M.D., David Orthopedic Surgeon (Texas Medical Association), Austin, TX Durden, David Associate Commissioner (Texas Department of Insurance), Austin, TX Evans, Darlene Administrator (Autumn Winds Retirement Lodge), Schertz, TX Fletcher, Howard (Self), Dripping Springs, TX Graves, Tim President (Texas Health Care Association), Austin, TX Hammond, Bill President (Texas Association of Business), Austin, TX Ireland, R.N., Rose (Advocates for Long Term Care Nurses), Austin, TX Jacks, Tommy Attorney (Mithoff and Jacks), Austin, TX James, Reggie Director (Consumers Union SW Regional Office), Austin, TX Jetton, Sheila Homemaker (Self), Austin, TX Kramer, David Attorney (Texas Legislative Council), Austin, TX Lambe, Dan (Texas Watch), Austin, TX Lindloff, Keith Attorney (Texas Children's Hospital), Houston, TX Linial, George (Texas Association of Homes & Services for the Aging), Austin, TX Maroney, M.D., Kimberly (San Patricio, Aransas & Refugio County Medical Society), Rockport, TX Meador, Ann Vice President (Methodist Retirement Communities), Conroe, TX Regier, Michael Vice President and General Counsel (Seton Healthcare Network), Austin, TX Russell, M.D., Peggy Physician (Texas Medical Directors Association), Austin, TX Sewell, Kelly Executive Director / Administrator (Seabury Center), Odessa, TX Thomason, David Public Policy Director (Texas Association of Homes & Services for the Aging), Austin, TX Trevey, John (TALA), Austin, TX