| Package | Description |
|---|---|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.io |
Provides classes and static methods that make object and primitive-type I/O easier and faster.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and 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.
|
| AbstractDouble2BooleanSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2ByteSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2CharSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2DoubleSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2FloatSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2IntSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2LongSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ObjectFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ObjectMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ObjectSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractDouble2ReferenceFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractDouble2ReferenceMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractDouble2ReferenceSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| AbstractDouble2ShortSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2BooleanFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2BooleanSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2ByteFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2ByteSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2CharFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2CharSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2DoubleFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2DoubleSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2FloatFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2FloatSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2IntFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2IntSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2LongFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2LongSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Double2ObjectArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ObjectAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ObjectFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ObjectFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Double2ObjectFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Double2ObjectFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Double2ObjectFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Double2ObjectLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ObjectMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ObjectMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ObjectMap.FastEntrySet
An entry set providing fast iteration.
|
| Double2ObjectMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Double2ObjectMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Double2ObjectMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Double2ObjectMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Double2ObjectOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ObjectOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ObjectRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ObjectSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ObjectSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Double2ObjectSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Double2ReferenceArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Double2ReferenceAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Double2ReferenceFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ReferenceFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Double2ReferenceFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Double2ReferenceFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Double2ReferenceFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Double2ReferenceLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Double2ReferenceMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Double2ReferenceMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Double2ReferenceMap.FastEntrySet
An entry set providing fast iteration.
|
| Double2ReferenceMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Double2ReferenceMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Double2ReferenceMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Double2ReferenceMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Double2ReferenceOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Double2ReferenceOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Double2ReferenceRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Double2ReferenceSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Double2ReferenceSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Double2ReferenceSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| 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.
|
| Double2ShortFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| Double2ShortSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| DoubleArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| DoubleArrays.Segment |
| DoubleArraySet
A simple, brute-force implementation of a set based on a backing array.
|
| DoubleBidirectionalIterator
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| DoubleBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| DoubleBigList
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleBigListIterator
A type-specific
BigListIterator . |
| DoubleBigListIterators.EmptyBigListIterator
A class returning no elements and a type-specific big list iterator interface.
|
| DoubleBigLists.EmptyBigList
An immutable class representing an empty type-specific big list.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| DoubleCollections.EmptyCollection
An immutable class representing an empty type-specific collection.
|
| DoubleCollections.SynchronizedCollection
A synchronized wrapper class for collections.
|
| DoubleCollections.UnmodifiableCollection
An unmodifiable wrapper class for collections.
|
| DoubleComparator
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| DoubleHash.Strategy
A type-specific hash strategy.
|
| DoubleHeapSemiIndirectPriorityQueue
A type-specific heap-based semi-indirect priority queue.
|
| 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. |
| DoubleIterators.EmptyIterator
A class returning no elements and a type-specific iterator interface.
|
| 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.
|
| 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 . |
| DoubleLists.EmptyList
An immutable class representing an empty type-specific list.
|
| DoubleLists.SynchronizedList
A synchronized wrapper class for lists.
|
| DoubleLists.UnmodifiableList
An unmodifiable wrapper class for 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.
|
| 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. |
| 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.
|
| DoubleSortedSet
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| DoubleSortedSets.EmptySet
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| DoubleStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and Description |
|---|
| 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. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
| Class and Description |
|---|
| AbstractDoubleCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractDoubleIterator
An abstract class facilitating the creation of type-specific iterators.
|
| DoubleCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| 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. |
Copyright © 2019. All rights reserved.


SHAAAAAAAAAAAAA
Check if your site's SSL certificate is using SHA-1 or SHA-2.
Nice. is using a certificate signed with . Start over.
Dang. is using a certificate signed with . Make a new cert using SHA-2. Start over.
Argh. There was an error checking . Start over.
Your SSL certificate was signed using a one-way hashing algorithm when it was created. It was probably SHA-1.
Which is too bad, because SHA-1 is becoming dangerously weak, and SHA-2 is the replacement.
My bank uses SHA-1. Am I in danger?
Probably not, for now. SHA-1 is getting weaker every year, but in the near term it's likely to be breakable only against very high profile targets.
But the Internet upgrades very slowly, so what's more urgent is that we all begin the transition now.
My site isn't that important. Do I have to care?
Yes. Be a part of the solution.
SHA-1 was broken in 2005, and one estimate suggests that in 2014 it costs $1-2 million to forge a SHA-1 certificate. For some actors, that's nothing.
Microsoft and Chrome recently deprecated SHA-1. They've promised dire consequences in 2016 and 2017, but they'll only be able to follow through on their threat to distrust SHA-1 if enough people update their certs before then.
If you're using a SHA-1 cert, take a few minutes and generate a new one with SHA-2.
openssl req -new -sha256 -key your-private.key -out your-domain.csr
Credits
Made by Eric Mill, released as open source. Thanks to Mathias Bynens for inspiration and assistance.


Maharashtra tussle: Fadnavis meets Governor, tenders resignation as CM
There has been no headway in government formation even a fortnight after Assembly poll results were announced on October 24.
by Press Trust of India.
Maharashtra Chief Minister Devendra Fadnavis resigned on Friday. Fadnavis drove to Raj Bhavan in south Mumbai and submitted his resignation to Governor Bhagat Singh Koshyari, sources said.
There has been no headway in government formation even a fortnight after Assembly poll results were announced on October 24.
The BJP and Shiv Sena are locked in a tussle over the issue of the chief minister's post, resulting in a stalemate in government formation despite the Assembly poll results giving the alliance a combined seat strength of 161, way past the 145 majority mark in the 288-member House.
In the polls, the BJP won 105 seats, Shiv Sena-56, NCP-54 and the Congress won 44 seats.


NEXTA Group
Home
Vision
About Us
Contact
Contact Us
NEXTA Corporate Avenue
Address:Jaibheema Nagar,560076
<EMAIL_ADDRESS>(+91)<PHONE_NUMBER>


LinkedIn to Json Résumé
This is a small website that exports your LinkedIn profile to a
JSON Résumé
.
Download as resume.json


CSU Library
The CSU Library Service Unit aims to support and achieve the educational objectives of CSU. It seeks relevant materials and services; and provide these to fulfull the vision,mission goals and objectives of the State College to respond to the changing needs of the clientele and the curricular offerings.
links
Library Website Web OPAC/Book CatalogMaria Corazon L. Tercera, RL
University Librarian


Abstract flow to be used for replacing one state with another, for example when changing the notary of a state.
Notably this requires a one to one replacement of states, states cannot be split, merged or issued as part of these
flows.
Get and check the required signature.
The CollectSignaturesFlow is used to automate the collection of counterparty signatures for a given transaction.
Verifies the given transaction, then sends it to the named notary. If the notary agrees that the transaction is acceptable then it is
from that point onwards committed to the ledger, and will be written through to the vault. Additionally it will be distributed to the
parties reflected in the participants list of the states.
A flow to be used for changing a state's Notary. This is required since all input states to a transaction
must point to the same notary.
A flow to be used by a party for obtaining signature(s) from a NotaryService ascertaining the transaction
time-window is correct and none of its inputs have been used in another completed transaction.
The receiving counterpart to FinalityFlow.
The ReceiveStateAndRefFlow should be called in response to the SendStateAndRefFlow.
The ReceiveTransactionFlow should be called in response to the SendTransactionFlow.
The SendStateAndRefFlow should be used to send a list of input StateAndRef to another peer that wishes to verify
the input's integrity by resolving and checking the dependencies as well. The other side should invoke ReceiveStateAndRefFlow
at the right point in the conversation to receive the input state and ref and perform the resolution back-and-forth
required to check the dependencies.
The SendTransactionFlow should be used to send a transaction to another peer that wishes to verify that transaction's
integrity by resolving and checking the dependencies as well. The other side should invoke ReceiveTransactionFlow at
the right point in the conversation to receive the sent transaction and perform the resolution back-and-forth required
to check the dependencies and download any missing attachments.
The SignTransactionFlow should be called in response to the CollectSignaturesFlow. It automates the signing of
a transaction providing the transaction:
Given a flow which uses reference states, the WithReferencedStatesFlow will execute the flow as a subFlow.
If the flow fails due to a NotaryError.Conflict for a reference state, then WithReferencedStatesFlow will be suspended until the
state refs for the reference states are consumed. In this case, a consumption means that:


Angular Libraries with ng-packagr
From Components to Angular Package Format.
David Herges
$ npm publish @your/components
Almost there?
-
Stylesheet Languages
css, scss, less — or styl? -
Know your consumers
Webpack, Angular CLI, SystemJS, Bazel, ... -
Back to the Future
Ahead-of-Time compilation -
Browser Support
Autoprefixer, Browserslist -
JavaScript Modules
FESM2015, FESM5, UMD -
What Next?
(…yet another tool for sure!)


Credits
Where it is due.
Highway photo from Splitshire
Street lamp photo from Splitshire
Toy car photo from DesignersPics
Vector photos from macrovector / Freepik
Remaining photos from Unsplash
Micons from Cosmin Negoita on Iconjar
Icons made by Smashicons and Freepik from www.flaticon.com
Social Media icons from Stephen Morley
Web and E-commerce icons from Pavel Kozlov on Gumroad
User icon created by Cris Dobbins from the Noun Project
Laptop Mockup from Panagiotis Efthymiou on Dribbble
Designed by Louis Davin Lie


Russia says not enough time left to draft new START arms control treaty: Ifax
by ReutersMOSCOW (Reuters) - Russia's foreign ministry said on Friday there was no longer enough time left for Moscow and Washington to draft a replacement to the New START nuclear arms control treaty before it expires in 2021, the Interfax news agency reported.
The New START treaty, which is the last major nuclear arms control treaty between Russia and the United States, limits the number of strategic nuclear warheads the world's two biggest nuclear powers can deploy.
"It's already obvious that in the time that is left... we will not be able to work out a full-fledged replacement document," Vladimir Leontyev, a foreign ministry official, was quoted as saying.
(Reporting by Andrey Kuzmin; writing by Tom Balmforth; Editing by Catherine Evans)


|
We wanted to let you know how thankful we are that you were able to spend our special day with us.
It meant so much to have you there supporting and having fun with us.
|
|
|
Thank you from the bottom of our hearts for {{ party.received_gifts }}.
We feel so blessed to have received that and pray that God blesses you tenfold.
|
|
{% if party.thank_you_extra_sentence %}
|
{{ party.thank_you_extra_sentence }}
|
|
{% endif %}
|
Thank you not only for the blessing you've been in our lives during our wedding, but especially in our lives
leading up to that day. We are looking forward to celebrating more happy occasions with you.
|
|


rawurlencode
(PHP 4, PHP 5, PHP 7)
rawurlencode — 按照 RFC 3986 对 URL 进行编码
说明
string rawurlencode ( string $str )
根据 » RFC 3986 编码指定的字符。
参数
str
要编码的 URL。
返回值
返回字符串，此字符串中除了 -_. 之外的所有非字母数字字符都将被替换成百分号（%）
后跟两位十六进制数。这是在 » RFC 3986 中描述的编码，是为了保护原义字符以免其被
解释为特殊的 URL 定界符，同时保护 URL 格式以免其被传输媒体（像一些邮件系统）使
用字符转换时弄乱。
Note:
在 PHP 5.3.0 之前，rawurlencode 根据 » RFC 1738 来编码波浪线（~）。
更新日志
版本 说明
5.3.4 因为 rawurlencode() 使用了 EBCDIC，所以波浪线字符不会再被编码。
5.3.0 现在符合了» RFC 3986。
范例
Example #1 在 FTP URL 里包含一个密码
';
?>
以上例程会输出：
或者，如果你想通过 URL 的 PATH_INFO 构成部分去传递信息：
Example #2 rawurlencode() 示例 2
';
?>
以上例程会输出：
参见
• rawurldecode() - 对已编码的 URL 字符串进行解码
• urldecode() - 解码已编码的 URL 字符串
• urlencode() - 编码 URL 字符串
• » RFC 3986
User Contributed Notes 23 notes
===============================================================================
I've written a simple function to convert an UTF-8 string to URL encoded
string. All the given characters are converted!
The function:
Example:
The above example will output:
http://example.com/%e4%bd%a0%e5%a5%bd
===============================================================================
Note that RFC 1738 has been amended:
The "[" and "]" are no longer considered unsafe, but instead are now considered
"reserved", meaning that they CAN be used in URLs!
Currently this usage has only been allowed in the hostname part, but there are
some proposals to allow such use in some URL schemes. Similar extensions are
now found that use the "{}" characters as "reserved" characters with special
semantics, instead of "unsafe" characters that must be URL encoded...
Note also that some characters are currently "reserved" but should have instead
been considered as "unsafe": this includes the parenthesis "()" which are
clearly unsafe when a URL is used in MIME headers.
Because of this, if a valid URL contains "()" characters, one should use an
upper-level encoding to either enclose the URL with a pair of "unsafe"
characters defined in the upper-level protocol (for example a "<>" pair in MIME
headers, because these characters cannot be part of a valid URL)...
===============================================================================
You can encode paths using:
===============================================================================
--- 1) About "reserved" characters in URLS:
Beware that RFC 1738 specifies that the characters "{", "}", "|", "\", "^",
"~", "[", "]", and "`" are all considered unsafe and SHOULD be URL-encoded with
a "%xx" triplet within *ALL* URLs.
However, some HTTP URLs seem to use the "~" character as a prefix for a user
account for example:
http://www.any.host.domain/~user/subpath/page.html?query#fragment
This usage is acceptable, but the RFC specifies that "%7E" should be used
instead of "~" in the path component. HTTP servers should accept "~" as being
equivalent to "%7E", and according to the RFC, the "%7E" form should be the
canonical one.
However, some HTTP servers are not fully complying to this RFC and consider
"%7E" differently from "~" (i.e. they consider it as being part of a path
component name, and search a directory name containing a "~" character, instead
of mapping the "~user" path component to a user's directory. In that case,
these non compliant HTTP server will not find the resource associated to that
URL and may return a 404 error or other errors such as an access denied.
When using rawurlencode() on such HTTP URLs, it's best to consider this legacy
usage, by using str_replace() on the result to convert back "/%7E" to "/~", so
that the URLs will correctly map to the legacy use of the "~" character by
these servers. On compliant HTTP servers, they will treat the "~" unsafe
character equivalently with the "%7E" recommanded form, so they will
automatically canonicalize the "~" character into "%7E".
--- 2) Encoding of hostnames in URLs
Finally, beware that host domain names parts in URLs *MUST NOT* be encoded with
rawurlencode(), as the "[" and "]" are valid delimiters that *MUST* be used to
reference an IPv6 address or other hostnames that don't fit to the restricted
set of characters allowed in a host name (the "[" and "]" characters MUST be
used if the hostname includes characters such as ":" which is typically used to
specify an alternate non-default port number).
The encoding of host names uses another encoding, required to encode
international domain names, with a base-64 encoding of Unicode characters and a
"bq--" prefix. This encoding must be used only on individual subdomain parts
(separated by "." characters). This encoding does not use any "%xx" triplets.
So NEVER use urlencode() or rawurlencode() on an unparsed URL, unless this full
URL is part of a query parameter string!
--- 3) Encoding of username/passwords in URLs:
There is no standard to specify a password in a URL. In fact, there's a legacy
usage of the ":" character to separate a username from a password, but it is
strongly discouraged. The RFC does not attempt to specify a semantic to the
authentication part of an URL (before the "@" character and the hostname part).
If you need to encode a password, always use rawurlencode() on username and
passwords separately, and then insert the ":" character to separate both
components. Don't use urlencode() (which could use a "+" to encode a space, and
would not work because usernames and passwords consider "+" and spaces as being
different!)
===============================================================================
phpversion()>=5.3 will compliant with RFC 3986, while phpversion()<=5.2.7RC1 is
not compliant with RFC 3986.
History of related RFCs:
RFC 1738 section 2.2
only alphanumerics, the special characters "$-_.+!*'(),", and
reserved characters used for their reserved purposes may be used
unencoded within a URL.
RFC 2396 section 2.3
unreserved = alphanum | mark
mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
RFC 2732 section 3
(3) Add "[" and "]" to the set of 'reserved' characters:
RFC 3986 section 2.3
unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
RFC 3987 section 2.2
unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
===============================================================================
rawurlencode() MUST not be used on unparsed URLs.
rawurlencode() should not be used on host and domain name parts (that may
include international characters encoded in each domain part with a "q--"
prefix followed by a special encoding of the international domain, currently in
testbed).
rawurlencode() may be used on usernames and passwords separately (so that it
won't encode the ':' and '@' separators).
rawurlencode() must not be used on paths (that may contain '/' separators): the
['path'] element of a parsed URL must first be exploded into individual
"directory" names. A directory or filename that contains a space must not be
encoded with urlencode() but with this rawurlencode(), so that it will appear
as a '%20' hex sequence (not '+')
rawurlencode() must not be used to encode the ['query'] element of a parsed
URL. Instead you must use the urlencode() function:
Typical queries often use the '&' separator between each parameter. This '&'
separator however is just a convention, used in the www-url-encoded format for
HTML forms using the default GET method. However, when references are done in a
HTML page to an URL that contains static query parameters, these '&' separators
should be encoded in the HTML code as '&' for HTML conformance. This is not
part of the URL specification, but of the HTML encapsulation! Some browsers
forget this, and send '&' with their HTTP GET query. You may wish to
substitute '&' by '&' when parsing and validating URLs. This should be done
BEFORE calling urlencode() on query parts.
The ['fragment'] part of a parsed URL (after the first '#' separator found in
any URL) must not be encoded with this rawurlencode() function but instead by
urlencode().
Validating a URL sent in a HTTP request is then more complicated than what you
may think. This must be done only on parsed URLs (where the basic elements of
an URL have been splitted), and then you must explode the path components, and
check the presence of '&' sequences in the query or fragment parts.
The next thing to do is to check the URL scheme that you want to support (for
example, only 'http', 'https', or 'ftp').
You may wich to check the ['port'] part to see if it's really a decimal integer
between 1 and 65535.
You may wish to remove the default port number used by the URL schemes you want
to support (for example the port '80' for 'http', the port '21' for 'ftp', the
port '443' for 'https'), and restrict severely all port numbers below 1024, or
some critical ports below 140 (this includes DNS and NetBios ports).
Then you may wish to control severely the ['host'] part (in fact a full host
domain name or an IP address), by forbidding those host names that don't
contain at least one dot, forbidding those that start with a dot, those that
contain two consecutive dots, those that start or finish with a '-' dash, those
that contain '.-' or '-.' (invalid in all domain names), those that contain two
dashes in another position than the second and third character of a domain name
part and not folled by at least one other character, forbid top level domain
names that have only one non numeric character, or more than 6 characters
(".museum" is, for now, the longest acceptable TLD), check that pseudo-TLD
names that are pure integers are effectively between 0 and 255, in that case
check that this is a valid IPv4 address by comparing it to long2ip(ip2long
($host)), ...
This done, you must use the urlencode() function on all parts up to the
exploded path elements, and rawurlencode() on the query and fragment parts,
according to the specs, to recreate a complete and validated URL.
===============================================================================
For those looking to strip all non-reserved characters from a URL according to
RFC 3986, the code would look like:
To get this string as it should be used in a url, you still probably want to
use rawurlencode, as the [:alpha:] posix bracket expression will catch accented
characters - use [A-Za-z][0-9] instead if you only want to include ascii
characters.
So a basic "slug" generation routine might look like:
===============================================================================
On the comments of rickyale and djmaze...
Is what you try to achieve is not a combination of utf8 and url encoding, e.g.
:
$str = "bl f Charl ne";
$enc = urlencode(utf8_encode($str));
$str2 = utf8_decode(urldecode($enc));
echo "$str -> $enc -> $str2";
?>
will output:
bl f Charl ne -> bl%C3%B8f+Charl%C3%A8ne -> bl f Charl ne
At least works for me, Jeroen Hofstee
===============================================================================
Easier version to 'rickyale at ig dot com dot br' his example
Just fill the regular expression with all characters that you need to have
encoded.
NOTE: 142 and up in his array are language specific ASCII characters so the
conversion to their unicode ('%C5%BD') equivelant may or may not work for you.
This needs a far more serious and bigger system to handle for non us tables
===============================================================================
If you, like me, sometimes have the misfortune of being forced to work with
PHP4, here is a PHP implementation of http_build_query() that produces more or
less the same output as this function, accepting the same arguments.
The only differences here are that the RFC selector argument does not behave
precisely correctly. This implementation passes RFC1738 through urlencode() and
RFC3986 through rawurlencode(), which is not 100% correct, see the manual pages
of those function for more information.
$item) $result[] = (is_array($item) ||
is_object($item)) ? http_build_query($item, NULL, $arg_separator, $enc_type, (
$base !== NULL) ? "$base%5B".$enc_func($key).'%5D' : $enc_func($key)) : (($base
!== NULL) ? "$base%5B".$enc_func($key).'%5D='.$enc_func($item) : ((is_int($key)
&& $numeric_prefix !== NULL) ? (string) $numeric_prefix : '').$enc_func($key).'
='.$enc_func($item));
return implode($arg_separator, $result);
}
}
===============================================================================
I had serious trouble with local Windows paths containing umlauts on my Apache
2 / Windows NT machine. Apache could not find any of those files if I just used
rawurlencode. It's not noted anywhere here, but you fix this by simply making
your path utf8 first:
rawurlencode(utf8_encode($str));
===============================================================================
Note in regards to 'rickyale at ig dot com dot br' program:
Wouldn't the whole issue be fixed by using charset=utf-8 in the HTML page?
I'm passing some data between the HTML form and an PHP program - my 'special'
characters have to do with the Polish alphabet - and it looks like JavaScript
encoding actually... works.
Of course, I could have tested only a limitted number of cases.
Just a thought.
===============================================================================
In addition to my last post I would like to add that, this function is for the
"directories/somefile.ext" paths
In order to construct valid ftp url (with password added in it )
do this
$valid_path = "ftp://" . rawurlencode($user) . ":" . rawurlencode($pass) .
ftp_url_encode($your_server_path_to_file)
Last function will encode path url so that language characters remain untouched
and you get same file name for download after download dialog appears.
===============================================================================
The microsoft URLEncode method ignores the documentation in RFC1738 which
states that:
".... the special characters "$-_.+!*'(),", and reserved characters used for
their reserved purposes may be used unencoded within a URL"
So for example<EMAIL_ADDRESS>becomes myaddress%40mydomain%2Ecom,
whereas php and other languages would encode this as myaddress%40mydomain.com
This can be an issue when porting from asp or if you are doing string
comparison of strings urlencoded on different platforms.
NB. php will correctly decode myaddress%40mydomain%2Ecom to
<EMAIL_ADDRESS>it is only the encoding that differs
===============================================================================
PHP's functions rawurlencode() and urlencode(), both encode the whole argument
parameter string, making the result useless as a valid link.
The function listed here encodes a link string (e.g. http://www.domain.com/
long_path/to\file.php?query=param#fragm) to a valid parameter
string, preserving the original URI structure and the path given.
function linkencode ($p_url) {
$ta = parse_url($p_url);
if (!empty($ta[scheme])) { $ta[scheme].='://'; }
if (!empty($ta[pass]) and !empty($ta[user])) {
$ta[user].=':';
$ta[pass]=rawurlencode($ta[pass]).'@';
} elseif (!empty($ta[user])) {
$ta[user].='@';
}
if (!empty($ta[port]) and !empty($ta[host])) {
$ta[host]=''.$ta[host].':';
} elseif (!empty($ta[host])) {
$ta[host]=$ta[host];
}
if (!empty($ta[path])) {
$tu='';
$tok=strtok($ta[path], "\\/");
while (strlen($tok)) {
$tu.=rawurlencode($tok).'/';
$tok=strtok("\\/");
}
$ta[path]='/'.trim($tu, '/');
}
if (!empty($ta[query])) { $ta[query]='?'.$ta[query]; }
if (!empty($ta[fragment])) { $ta[fragment]='#'.$ta[fragment]; }
return implode('', array($ta[scheme], $ta[user], $ta[pass], $ta[host], $ta
[port], $ta[path], $ta[query], $ta[fragment]));
}
===============================================================================
I have to mention something about javier's post: the issue you are experiencing
only happens because you are using ISO-8859-1 (a.k.a. ISO-LATIN-1) encoding,
which is an extension of ASCII using the values 128-255 for latin specific
characters (these characters are NOT part of ASCII). To say somethig like 0xF1
is the correct value for "ñ" in ASCII is wrong: any value equal or higher than
0x80 is invalid in ASCII; and there is no "correct" value for "ñ" in ASCII
because the ASCII character set does not include that character.
These encode/decode functions are designed to work on UTF-8, which is an
ASCII-compatible encoding for Unicode, thus being able to represent the entire
Unicode character range.
The main point is: the "Ã±" you get is the 0xC3 0xB1 sequence, interpreted as
two single-byte ISO-8859-1 characters; but if you interpret them as UTF-8, they
indeed represent "ñ". If you are working with the latin character set and
encoding, then you are fine with your method (which is essentially a utf-8 =>
iso-latin-1 converter).
For anybody who is using UTF-8 enconding, check if there is any issue before
you use a method like javier's: these multi-byte values are actually the right
way to represent any non-ASCII character on UTF-8.
For deeper details on the UTF-8 and ISO-8859-1 encodings, take a look at
wikipedia:
http://en.wikipedia.org/wiki/UTF-8
http://en.wikipedia.org/wiki/ISO-8859-1
===============================================================================
0x00,
1 => 0x01,
2 => 0x02,
3 => 0x03,
4 => 0x04,
5 => 0x05,
6 => 0x06,
7 => 0x07,
8 => 0x08,
9 => 0x09,
"A"=> 0x0a,
"B"=> 0x0b,
"C"=> 0x0c,
"D"=> 0x0d,
"E"=> 0x0e,
"F"=> 0x0f
);
# Looking for latin characters with a pattern like this %C3%[A-Z0-9]{2}
ie. -> %C3%B1 = 'ñ'
if(preg_match_all("/\%C3\%([A-Z0-9]{2})/i",$raw_url_encoded,$res))
{
$res = array_unique($res = $res[1]);
$arr_unicoded = array();
foreach($res as $key => $value){
$arr_unicoded[] = chr(
(0xc0 | ($hex_table[substr($value,0,1)]<<4)) | (0x03 &
$hex_table[substr($value,1,1)])
);
$res[$key] = "%C3%" . $value;
}
$raw_url_encoded = str_replace($res,$arr_unicoded,$raw_url_encoded
);
}
# Return raw url decoded
return rawurldecode($raw_url_encoded);
}
# Testing
print "Decoded character -> " . urlRawDecode("%C3%B1");
// ouput:
// Decoded chracter -> ñ
/*
:: A little explanation about what does this function do ::
-----------------------------------------------------
This function makes two binary operations between C3 and B1. To get an ASCII
representation of this kind of raw url encoded character, we have to make a
logical OR between HIGH nibble of 0xC3 (0xC) and HIGH nibble of 0xB1 (0xB) ->
(0xC0 | 0xB0), then, a logical AND between both LOW nibble (0x03 & 0x01), and
finally we have to make a logical OR between these two results -> [hex] ((0xC0
| 0xB0) | (0x03 & 0x01)) = [binary] ((1100 0000 | 1011 0000) | (0000 0011 &
0000 0001)) = [hex] 0xF1 = [binary] 1111 0001 = "ñ" character.
Hope to be helpfull, if you have an issue like this, try to use this function.
Bye,
Javi =)
*/
?>
===============================================================================
As peter@nospam said, the microsoft uses an different table for encode string
when sending data...
with some test i have created a table with this encodes for special char like
here is it for those who need know what is this table..
the index of array is the ord() of a character..
use with chr(index) to know the char.. and replace with the value.....
var $ENCODE_TABLE = ARRAY(33=>'%21', 35=>'%23', 36=>'%24', 37=>'%25', 38=>
'%26', 40=>'%28', 41=>'%29', 43=>'%2B', 44=>'%2C', 47=>'%2F', 58=>'%3A', 59=>
'%3B', 60=>'%3C', 61=>'%3D', 62=>'%3E', 63=>'%3F', 91=>'%5B', 92=>'%5C', 93=>
'%5D', 123=>'%7B', 124=>'%7C', 125=>'%7D', 142=>'%C5%BD', 192=>'%C3%80', 193=>
'%C3%81', 194=>'%C3%82', 195=>'%C3%83', 196=>'%C3%84', 197=>'%C3%85', 199=>
'%C3%87', 200=>'%C3%88', 201=>'%C3%89', 202=>'%C3%8A', 203=>'%C3%8B', 204=>
'%C3%8C', 205=>'%C3%8D', 206=>'%C3%8E', 207=>'%C3%8F', 210=>'%C3%92', 211=>
'%C3%93', 212=>'%C3%94', 213=>'%C3%95', 214=>'%C3%96', 217=>'%C3%99', 218=>
'%C3%9A', 219=>'%C3%9B', 220=>'%C3%9C', 221=>'%C3%9D', 224=>'%C3%A0', 225=>
'%C3%A1', 226=>'%C3%A2', 227=>'%C3%A3', 228=>'%C3%A4', 229=>'%C3%A5', 231=>
'%C3%A7', 232=>'%C3%A8', 233=>'%C3%A9', 234=>'%C3%AA', 235=>'%C3%AB', 236=>
'%C3%AC', 237=>'%C3%AD', 238=>'%C3%AE', 239=>'%C3%AF', 242=>'%C3%B2', 243=>
'%C3%B3', 244=>'%C3%B4', 245=>'%C3%B5', 246=>'%C3%B6', 249=>'%C3%B9', 250=>
'%C3%BA', 251=>'%C3%BB', 252=>'%C3%BC', 253=>'%C3%BD', 255=>'%C3%BF');
example::
function encode($text) {
while(list($ord, $enc) = each($ENCODE_TABLE)) {
$text = str_replace(chr($ord), $enc, $text);
}
return $text;
}
hope this help ...
===============================================================================
Be careful here. rawurlencode changes ä to %C3%83%C2%A4 but firefox changes
this internally to %c3%83%c2%a4. This could lead to bugs with rewrite loops.
Cheers.
===============================================================================
This seems the correct way to encode ftp url which you could provide for your
users:
function ftp_url_encode($string) {
$hex="";
$retstr = "";
for ($i=0; $i < strlen($string) ;$i++) {
$char = $string[$i];
if(($char >= '0' && $char <= '9') || ($char >= 'A' && $char <= 'Z') ||
($char >= 'a' && $char <= 'z') || $char == '.' || $char == '-' || $char == '/'
|| (ord($char) >=128) ) $retstr .= $char;
else
$retstr .= "%".strtoupper(dechex(ord($string[$i])));
}
return $retstr;
}
Browsers mangle certain language characters
===============================================================================
note that if you implement your own server request engine in the HTTP manner
like:
GET $request_uri
you should first split all parts of the $request_uri path and rawurlencode()
each part, then concatenate those parts back again. this function will
translate the URI correctly:
function translate_uri($uri) {
$parts = explode('/', $uri);
for ($i = 0; $i < count($parts); $i++) {
$parts[$i] = rawurlencode($parts[$i]);
}
return implode('/', $parts);
}
because if you do rawurlencode() over the whole URI, path separator characters
'/' are also encoded and request will not happen to be correct. '/' characters
should not be encoded, only those parts in between.
hope this helps someone like me...
===============================================================================
About the ";" reserved character in URLs:
rawurlencode() will encode it with a "%2A" triplet. When used on the path part
of a URL, this will break the usage defined in URL RFCs, that allows specifying
additional parameters to *EACH* element of a path (separated by "/").
So if a path element contains a ";" character (some filesystems allow it, but
this is not recommanded) as part of a directory name, this character must be
encoded so that it won't be mixed with a parameter extension.
This mapping is allowed on URLs that use a hierarchical scheme (HTTP, HTTPS,
FTP, FILE, ...), so that each path element prefixed by "/" can have additional
navigational parameters such as authorization strings or semantic parameters.
The generic format of a path element may include path elements such as:
"/." or "/.." or "/.specialname" or "/regularname"
Each part may be followed by a ";" and other parameters separated by ";". These
parameters can be eithger ordered or unordered. Unordered parameters have a
symbolic name separated from their value with an equal sign.
Do not mix path element parameters with a query string: these parameters are
directly attached to the individual path element, and this makes a difference
when this path element is not the last one of the URL. These parameters are
part of the resource name (unlike the query string), and the semantic of "."
and ".." apply to the full path element with its parameters, so that:
"/subdir1/subdir2/page.html;charset=UTF-8/../index.html"
will resolve to "/subdir1/index.html".
Note that:
"/subdir1/subdir2/page.html;charset=UTF-8"
designates a DISTINCT resource name from:
"/subdir1/subdir2/page.html"
It does not necessarily involves a query, and so it can be cached by default
(unlike URLs that contain a query string).
When using path element parameters, their optional name and required value must
be rawurlencode()'d separately before inserting ";" and "=" parameters and
creating the path elements that will be imploded in the full path.
The consequence is that you MUST not urlencode() or rawurlencode individual
path elements, without first parsing them:
- first explode the path into its path lements separated by "/"
- then explode each path element in their name and parameters separated by ";"
characters
- then split path element parameters that contain a "=" sign into a name/value
pair.
- make sure that unordered path paremeters (that have been cut according to "="
into a pair) are specified *after* ordered parameters (including the main path
element name) in each path element, and that no two unordered parameters have
the same name (this restriction does not occur on unordered, unnamed parameters
which only supply a value).
- finally you can interpret rawurlencoded names and values that constitute each
path element.
Note also that some non-compliant HTTP servers consider that named parameters
are ordered, and don't add a semantic to the ";" and "=" used to break up the
list of path element parameters. On client agents, when validating URLs, it's
best then not to try to interpret this list, and you should just split the main
part of a path element and the parameters list by isolating the first ";" that
introduces this list. However, the encoded parameter list cannot include any "/
" parameter.
Caveats: note that path element parameters (introduced by ";") may be used on
upper levels of a hierarchic URL, even before the final document name and its
query parameters. When building lists of URLs, you should not separate URLs
blindly with a ";" separator, as each URL may include a ";" character, in their
path part (the ";" character cannot ocur safely in a query string). In that
case, use a surrounding pair such as "<>" or quotes to enclose each URL in such
a list.
===============================================================================
I have attempted to incorporate all of the previous comments, plus several bug
fixes, into dphantom's linkencode. I see no bugs for these test cases:
http://example.com/path1;var1=val1/p2;v2
http://example.com/p1;v1/p2;v2
http://[ip:v6:440]:8080
http://example.com:8080
http://example.com/~joe
http://example.com/foobar/~joe
http://username:password@hostname/path 1//path 2/?arg 1=value 1&arg 2=value 2#
fragment identifier
hostname/path 1//path 2/?arg 1=value 1&arg 2=value 2#fragment identifier
http://invalid_host..name/
function linkencode($p_url){
$uparts = @parse_url($p_url);
$scheme = array_key_exists('scheme',$uparts) ? $uparts['scheme'] : "";
$pass = array_key_exists('pass',$uparts) ? $uparts['pass'] : "";
$user = array_key_exists('user',$uparts) ? $uparts['user'] : "";
$port = array_key_exists('port',$uparts) ? $uparts['port'] : "";
$host = array_key_exists('host',$uparts) ? $uparts['host'] : "";
$path = array_key_exists('path',$uparts) ? $uparts['path'] : "";
$query = array_key_exists('query',$uparts) ? $uparts['query'] : "";
$fragment = array_key_exists('fragment',$uparts) ? $uparts['fragment'] :
"";
if(!empty($scheme))
$scheme .= '://';
if(!empty($pass) && !empty($user)) {
$user = rawurlencode($user).':';
$pass = rawurlencode($pass).'@';
} elseif(!empty($user))
$user .= '@';
if(!empty($port) && !empty($host))
$host = ''.$host.':';
elseif(!empty($host))
$host=$host;
if(!empty($path)){
$arr = preg_split("/([\/;=])/", $path, -1, PREG_SPLIT_DELIM_CAPTURE); //
needs php > 4.0.5.
$path = "";
foreach($arr as $var){
switch($var){
case "/":
case ";":
case "=":
$path .= $var;
break;
default:
$path .= rawurlencode($var);
}
}
// legacy patch for servers that need a literal /~username
$path = str_replace("/%7E","/~",$path);
}
if(!empty($query)){
$arr = preg_split("/([&=])/", $query, -1, PREG_SPLIT_DELIM_CAPTURE); //
needs php > 4.0.5.
$query = "?";
foreach($arr as $var){
if( "&" == $var || "=" == $var )
$query .= $var;
else
$query .= urlencode($var);
}
}
if(!empty($fragment))
$fragment = '#'.urlencode($fragment);
return implode('', array($scheme, $user, $pass, $host, $port, $path, $query,
$fragment));
}


WITNESS LIST Appropriations-S/C on Education Committee February 8, 2005-7:00A Budget On: Adauto, Richard (University of Texas at El Paso) Ambrosino, Rosalie (University of Texas at San Antonio) Calvert, Stanton C. (The Texas A&M University System) Cardenas, Blandina (University of Texas- Pan American) Crain, B.J. (Texas A&M University System) Dunn, Dana (The University of Texas at Arlington) Eckland-Olsen, Sheldon (University of Texas at Austin) Faulkner, Larry R. (The University of Texas at Austin) Garcia, Juliet V. (Self and The University of Texas at Brownsville) Gates, Robert (Texas A&M University) Hearn, William C. (Texas A&M University at Galveston) Hensley, Stephen (Texas A&M University- Texarkana) Jenifer, Franklyn G. (University of Texas at Dallas) Juarez, Rumaldo Z. (Texas A&M University- Kingsville) Keck III, Ray M. (Texas A&M International University) Kennedy, Kerry (The University of Texas at San Antonio) Killebrew, Flavius (Texas A&M University- Corpus Christi) Long, Russell (West Texas A&M University) Mabry, Rodney H. (The University of Texas at Tyler) McCabe, Dennis P. (Tarleton State University) McFarland, Keith D. (Texas A&M University- Commerce) McTeer, Robert (The Texas A&M University System) Romo, Dr. Ricardo (University of Texas at San Antonio) Spaniolo, James D. (University of Texas at Arlington) Wallace, Randy (The University of Texas System) Ward, Rusty (The University of Texas at Arlington) Watts, David (The University of Texas of the Permian Basin) Williams, Dan (Prarie View A&M University) Yudof, Mark (The University of Texas System)


{% include "templates/includes/_header.html" %} {% block main %} {% endblock %} {% include "templates/includes/_footer.html" %}


{% extends "base.html" %} {% load i18n %} {% block metatitle %} {% trans "Disable Two-factor Authentication" %} {% endblock %} {% block title %}
{% blocktrans trimmed %} You are about to disable two-factor authentication. This compromises your account security, are you sure? {% endblocktrans %}
{% endblock %}


Page Maximal Unique Matches
Example for using the Mums Iterator.
Given a set of sequences, a unique match is a match that occurs exactly once in each sequence. A maximal unique match (MUM) is a unique match that is not part of any longer unique match. The following example demonstrates how to iterate over all MUMs and output them.
///A tutorial about finding Mums. #include <iostream> #include <seqan/index.h> using namespace seqan; int main() { // We begin with a StringSet that stores multiple strings. StringSet<String<char> > mySet; resize(mySet, 3); mySet[0] = "SeqAn is a library for sequence analysis."; mySet[1] = "The String class is the fundamental sequence type in SeqAn."; mySet[2] = "Subsequences can be handled with SeqAn's Segment class."; // Then we create an Index of this StringSet. typedef Index<StringSet<String<char> > > TMyIndex; TMyIndex myIndex(mySet); // To find maximal unique matches (Mums), we use the Mums Iterator and set the minimum MUM length to 3. Iterator<TMyIndex, Mums>::Type myMUMiterator(myIndex, 3); String<SAValue<TMyIndex>::Type> occs; while (!atEnd(myMUMiterator)) { // A multiple match can be represented by the positions it occurs at in every sequence and its length. // getOccurrences@ returns an unordered sequence of pairs (seqNo,seqOfs) the match occurs at. occs = getOccurrences(myMUMiterator); //To order them ascending according seqNo we use orderOccurrences. orderOccurrences(occs); for (unsigned i = 0; i < length(occs); ++i) std::cout << getValueI2(occs[i]) << ", "; // repLength returns the length of the match. std::cout << repLength(myMUMiterator) << " "; // The match string itself can be determined with representative. std::cout << "\t\"" << representative(myMUMiterator) << '\"' << std::endl; ++myMUMiterator; } return 0; }
Demo: demos/dox/index/mums.cpp
The only maximal matches that occur in all 3 sequences are "SeqAn" and "sequence". They occur exactly once and thus are maximal unique matches.
weese@tanne:~/seqan$ cd demos weese@tanne:~/seqan/demos$ make index_mums weese@tanne:~/seqan/demos$ ./index_mums 0, 53, 33, 5 "SeqAn" 23, 36, 3, 8 "sequence" weese@tanne:~/seqan/demos$ *


FROM(1) BSD General Commands Manual FROM(1) NAME from — print names of those who have sent mail SYNOPSIS from [-c] [-f file] [-s sender] [user] DESCRIPTION The from utility prints out the mail header lines from the invoker's mail‐ box. The following options are available: -c Just print a count of messages and exit. -f file The supplied file is examined instead of the invoker's mailbox. If the -f option is used, the user argument should not be used. Read from standard input if file name “-” is given. -s sender Only mail from addresses containing the supplied string are printed. If user is given, the user's mailbox is examined instead of the invoker's own mailbox. (Privileges are required.) ENVIRONMENT MAIL If set, the location of the invoker's mailbox. Otherwise, the default in /var/mail is used. FILES /var/mail/* SEE ALSO biff(1), mail(1) HISTORY The from command appeared in 3.0BSD. BSD December 30, 1993 BSD


Material gate pass / Gate {{$ctrl.type}}
Created on : {{$ctrl.material_gate_pass.created_at ? $ctrl.material_gate_pass.created_at : ''}}
Material successfully gated In
Material Gate Pass No :
Material successfully gated Out
Received from OSL Vendor Mobile +91


Enter your move below to play Rock, Paper, Scissors!
For Rock, type "r"
For Paper, type "p"
For Scissors, type "s"
Player 1
Player 2
Play!


CDK stepper provides a foundation upon which more concrete stepper varities can be built. A stepper is a wizard-like workflow that divides content into logical steps
The base CDK version of the stepper primarily manages which step is active. This includes handling keyboard interactions and exposing an API for advancing or rewinding through the workflow.
A stepper marked as linear
requires the user to complete previous steps before proceeding.
For each step, the stepControl
attribute can be set to the top level
AbstractControl
that is used to check the validity of the step.
There are two possible approaches. One is using a single form for stepper, and the other is using a different form for each step.
When using a single form for the stepper, any intermediate next/previous buttons within the steps
must be set to type="button"
in order to prevent submission of the form before all steps are
complete.
When using a form for each step, the workflow is advanced whenever one of the forms is submitted.
If completion of a step in linear stepper is not required, then the optional
attribute can be set
on CdkStep
in a linear
stepper.
By default, steps are editable, which means users can return to previously completed steps and
edit their responses. editable="true"
can be set on CdkStep
to change the default.
By default, the completed
attribute of a step returns true
if the step is valid (in case of
linear stepper) and the user has interacted with the step. The user, however, can also override
this default completed
behavior by setting the completed
attribute as needed.
There are two button directives to support navigation between different steps:
CdkStepperNext
and CdkStepperPrevious
. When placed inside of a step, these will automatically
add click handlers to advance or rewind the workflow, respectively.
The CDK stepper is treated as a tabbed view for accessibility purposes, so it is given
role="tablist"
by default. The header of step that can be clicked to select the step
is given role="tab"
, and the content that can be expanded upon selection is given
role="tabpanel"
. aria-selected
attribute of step header and aria-expanded
attribute of
step content is automatically set based on step selection change.
The stepper and each step should be given a meaningful label via aria-label
or aria-labelledby
.


new Facility()
Facility Model and Collection w/ methods
- Source:
Methods
-
comparator(facility) → {String}
-
Allows sorting of facilities by facility title
Parameters:
Name Type Description facility
Facility to pull title - Source:
Returns:
title of facility- Type
- String
-
filterByIds(idArray) → {Facility[]}
-
Get facilities from collection based on an array of facility ids
Parameters:
Name Type Description idArray
int[] array of facilities to get - Source:
Returns:
items with matching facilityIds- Type
- Facility[]


| UTF-16 |
|---|
| UTF-8 |
|---|
| Decimal HTML entity |
|---|
| Block |
|---|
| Introduced in |
|---|
| General category |
|---|
| Unihan Mandarin |
|---|
| Hexadecimal | |
|---|---|
| Decimal | |
| Character |
This is a Unicode character map. It supports all of the codepoints and planes that are currently available as of Unicode (version).
In addition to details about encodings, blocks, ages, and categories, the names of characters are augmented by definitions from the Unihan database, where appropriate.
Source is available under the ISC licence.
Keyboard shortcuts
Home: go to first visible character
Home Home: go to U+0000
End: go to last visible character
End End: go to U+10FFFF
Page Up: show the previous page
Page Down: show the next page
Arrow keys: navigate the character map
Credits
Unicode Character Database: Unicode
Consortium
Symbola font: George Douros
Twemoji font: Brad Erickson and others
lzo1x library: Alistair Braidwood
Browser compatibility
Chrome 23: perfect
Firefox 17: perfect
IE 10: perfect
Opera 12: some UI problems
Safari 5: only BMP characters