boolean as an object.
* @param {boolean} value
* @class
*/
class BooleanHelper implements java.lang.Comparablechar as an object.
*
* TODO(jat): many of the classification methods implemented here are not
* correct in that they only handle ASCII characters, and many other methods are
* not currently implemented. I think the proper approach is to introduce * a
* deferred binding parameter which substitutes an implementation using a
* fully-correct Unicode character database, at the expense of additional data
* being downloaded. That way developers that need the functionality can get it
* without those who don't need it paying for it.
*
*
* The following methods are still not implemented -- most would require Unicode
* character db to be useful:
* - digit / is* / to*(int codePoint)
* - isDefined(char)
* - isIdentifierIgnorable(char)
* - isJavaIdentifierPart(char)
* - isJavaIdentifierStart(char)
* - isJavaLetter(char) -- deprecated, so probably not
* - isJavaLetterOrDigit(char) -- deprecated, so probably not
* - isISOControl(char)
* - isMirrored(char)
* - isSpaceChar(char)
* - isTitleCase(char)
* - isUnicodeIdentifierPart(char)
* - isUnicodeIdentifierStart(char)
* - getDirectionality(*)
* - getNumericValue(*)
* - getType(*)
* - reverseBytes(char) -- any use for this at all in the browser?
* - toTitleCase(*)
* - all the category constants for classification
*
* The following do not properly handle characters outside of ASCII:
* - digit(char c, int radix)
* - isDigit(char c)
* - isLetter(char c)
* - isLetterOrDigit(char c)
* - isLowerCase(char c)
* - isUpperCase(char c)
*
* @param {string} value
* @class
*/
class CharacterHelper implements java.lang.Comparable
* The returned comparator is serializable if the specified comparator is also
* serializable.
*
* @param
* Each observer has its
* Implementation notes:
*
* A key's hashCode is the index in backingMap which should contain that key. Since several keys may
* have the same hash, each value in hashCodeMap is actually an array containing all entries whose
* keys share the same hash.
* @param {java.util.AbstractHashMap} host
* @class
*/
class InternalHashCodeMap
* If the
* Note that if delim is null, this constructor does
* not throw an exception. However, trying to invoke other methods on the
* resulting StringTokenizer may result in a
* NullPointerException.
*
* @param {string} str a string to be parsed.
* @param {string} delim the delimiters.
* @param {boolean} returnDelims flag indicating whether to return the delimiters
* as tokens.
* @exception NullPointerException if str is
* Note: Any changes to this class should put into account the assumption that
* was made in rest of the JRE emulation.
* @class
*/
class Locale {
static ROOT: Locale;
static ROOT_$LI$(): Locale;
static ENGLISH: Locale;
static ENGLISH_$LI$(): Locale;
static US: Locale;
static US_$LI$(): Locale;
static FRANCE: Locale;
static FRANCE_$LI$(): Locale;
static UK: Locale;
static UK_$LI$(): Locale;
static defaultLocale: Locale;
static defaultLocale_$LI$(): Locale;
/**
* Returns an instance that represents the browser's default locale (not
* necessarily the one defined by 'gwt.locale').
* @return {java.util.Locale}
*/
static getDefault(): Locale;
constructor();
}
namespace Locale {
class RootLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
class EnglishLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
class FrenchLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
class USLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
class UKLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
class DefaultLocale extends java.util.Locale {
/**
*
* @return {string}
*/
toString(): string;
constructor();
}
}
}
export declare namespace java.util.concurrent {
interface Callable
* If this dictionary already contains an entry for the specified
* key, the value already in this dictionary for that
* key is returned, after modifying the entry to contain the
* new element. If this dictionary does not already have an entry
* for the specified key, an entry is created for the
* specified key and value, and null is
* returned.
*
* The
* Example:
*
* null to this method will have no effect.
*
* @param {*} o
* the observer to be deleted.
*/
deleteObserver(o: java.util.Observer): void;
notifyObservers$(): void;
notifyObservers$java_lang_Object(arg: any): void;
/**
* If this object has changed, as indicated by the hasChanged
* method, then notify all of its observers and then call the
* clearChanged method to indicate that this object has no
* longer changed.
* update method called with two
* arguments: this observable object and the arg argument.
*
* @param {*} arg
* any object.
* @see java.util.Observable#clearChanged()
* @see java.util.Observable#hasChanged()
* @see java.util.Observer#update(java.util.Observable, java.lang.Object)
*/
notifyObservers(arg?: any): any;
/**
* Clears the observer list so that this object no longer has any observers.
*/
deleteObservers(): void;
/**
* Marks this Observable object as having been changed; the
* hasChanged method will now return true.
*/
setChanged(): void;
/**
* Indicates that this object has no longer changed, or that it has already
* notified all of its observers of its most recent change, so that the
* hasChanged method will now return false. This method is
* called automatically by the notifyObservers methods.
*
* @see java.util.Observable#notifyObservers()
* @see java.util.Observable#notifyObservers(java.lang.Object)
*/
clearChanged(): void;
/**
* Tests if this object has changed.
*
* @return {boolean} true if and only if the setChanged
* method has been called more recently than the
* clearChanged method on this object;
* false otherwise.
* @see java.util.Observable#clearChanged()
* @see java.util.Observable#setChanged()
*/
hasChanged(): boolean;
/**
* Returns the number of observers of this Observable object.
*
* @return {number} the number of observers of this object.
*/
countObservers(): number;
}
}
export declare namespace java.util {
/**
* A simple wrapper around JavaScriptObject to provide {@link java.util.Map}-like semantics for any
* key type.
* delim argument are the delimiters
* for separating tokens.
* returnDelims flag is true, then
* the delimiter characters are also returned as tokens. Each
* delimiter is returned as a string of length one. If the flag is
* false, the delimiter characters are skipped and only
* serve as separators between tokens.
* null
* @class
* @author unascribed
*/
class StringTokenizer implements java.util.Enumerationtrue if and only if there is at least one token
* in the string after the current position; false
* otherwise.
*/
hasMoreTokens(): boolean;
nextToken$(): string;
nextToken$java_lang_String(delim: string): string;
/**
* Returns the next token in this string tokenizer's string. First,
* the set of characters considered to be delimiters by this
* StringTokenizer object is changed to be the characters in
* the string delim. Then the next token in the string
* after the current position is returned. The current position is
* advanced beyond the recognized token. The new delimiter set
* remains the default after this call.
*
* @param {string} delim the new delimiters.
* @return {string} the next token, after switching to the new delimiter set.
* @exception NoSuchElementException if there are no more tokens in this
* tokenizer's string.
* @exception NullPointerException if delim is null
*/
nextToken(delim?: any): any;
/**
* Returns the same value as the hasMoreTokens
* method. It exists so that this class can implement the
* Enumeration interface.
*
* @return {boolean} true if there are more tokens;
* false otherwise.
* @see java.util.Enumeration
* @see java.util.StringTokenizer#hasMoreTokens()
*/
hasMoreElements(): boolean;
/**
* Returns the same value as the nextToken method,
* except that its declared return value is Object rather than
* String. It exists so that this class can implement the
* Enumeration interface.
*
* @return {*} the next token in the string.
* @exception NoSuchElementException if there are no more tokens in this
* tokenizer's string.
* @see java.util.Enumeration
* @see java.util.StringTokenizer#nextToken()
*/
nextElement(): any;
/**
* Calculates the number of times that this tokenizer's
* nextToken method can be called before it generates an
* exception. The current position is not advanced.
*
* @return {number} the number of tokens remaining in the string using the current
* delimiter set.
* @see java.util.StringTokenizer#nextToken()
*/
countTokens(): number;
}
}
export declare namespace java.util.regex {
class Matcher implements java.util.regex.MatchResult {
_pattern: java.util.regex.Pattern;
text: string;
starts: number[];
ends: number[];
groups: string[];
/**
* The range of string that last matched the pattern. If the last
* match failed then first is -1; last initially holds 0 then it
* holds the index of the end of the last match (which is where the
* next search starts).
*/
first: number;
/**
* The range of string that last matched the pattern. If the last
* match failed then first is -1; last initially holds 0 then it
* holds the index of the end of the last match (which is where the
* next search starts).
*/
last: number;
/**
* The index of the last position appended in a substitution.
*/
lastAppendPosition: number;
constructor(_pattern: java.util.regex.Pattern, text: string);
hasGroups(): void;
searchWith(regExp: RegExp): boolean;
end$(): number;
end$int(i: number): number;
end$java_lang_String(string: string): number;
end(string?: any): any;
find$(): boolean;
find$int(start: number): boolean;
find(start?: any): any;
group$(): string;
group$int(i: number): string;
group$java_lang_String(string: string): string;
group(string?: any): any;
/**
*
* @return {number}
*/
groupCount(): number;
hitEnd(): boolean;
lookingAt(): boolean;
matches(): boolean;
pattern(): java.util.regex.Pattern;
regionEnd(): number;
regionStart(): number;
replaceAll(replacement: string): string;
replaceFirst(replacement: string): string;
reset$(): Matcher;
reset$java_lang_CharSequence(input: any): Matcher;
reset(input?: any): any;
start$(): number;
start$int(i: number): number;
start$java_lang_String(string: string): number;
start(string?: any): any;
toMatchResult(): java.util.regex.MatchResult;
usePattern(newPattern: java.util.regex.Pattern): Matcher;
}
namespace Matcher {
class IndexGetter {
regexString: string;
parenthesisStart: number[];
parenthesisEnd: number[];
starts: number[];
ends: number[];
startLastIndex: number;
constructor(regexString: string, parenthesisStart: number[], parenthesisEnd: number[], starts: number[], ends: number[], startLastIndex: number);
/**
*
* @param {Array} args
* @return {string}
*/
apply(args: string[]): string;
}
class NonCapturesToCaptures {
start: number[];
ends: number[];
constructor(start: number[], ends: number[]);
/**
*
* @param {Array} args
* @return {string}
*/
apply(args: string[]): string;
}
class FirstReplacer {
replacement: string;
first: boolean;
constructor(replacement: string);
/**
*
* @param {Array} args
* @return {string}
*/
apply(args: string[]): string;
}
}
}
export declare namespace java.util.regex {
class Pattern implements java.io.Serializable {
static CASE_INSENSITIVE: number;
static MULTILINE: number;
static UNICODE_CASE: number;
static UNICODE_CHARACTER_CLASS: number;
regexp: RegExp;
_flags: number;
namedGroupsNames: java.util.Maptrue if this dictionary maps no keys to values;
* false otherwise.
*/
isEmpty(): boolean;
/**
* Returns an enumeration of the keys in this dictionary. The general
* contract for the keys method is that an Enumeration object
* is returned that will generate all the keys for which this dictionary
* contains entries.
*
* @return {*} an enumeration of the keys in this dictionary.
* @see java.util.Dictionary#elements()
* @see java.util.Enumeration
*/
keys(): java.util.Enumerationnull if the key is not mapped to any value in
* this dictionary.
* @exception NullPointerException if the key is null.
* @see java.util.Dictionary#put(java.lang.Object, java.lang.Object)
*/
get(key: any): V;
/**
* Maps the specified key to the specified
* value in this dictionary. Neither the key nor the
* value can be null.
* value can be retrieved by calling the
* get method with a key that is equal to
* the original key.
*
* @param {*} key the hashtable key.
* @param {*} value the value.
* @return {*} the previous value to which the key was mapped
* in this dictionary, or null if the key did not
* have a previous mapping.
* @exception NullPointerException if the key or
* value is null.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.util.Dictionary#get(java.lang.Object)
*/
put(key: K, value: V): V;
/**
* Removes the key (and its corresponding
* value) from this dictionary. This method does nothing
* if the key is not in this dictionary.
*
* @param {*} key the key that needs to be removed.
* @return {*} the value to which the key had been mapped in this
* dictionary, or null if the key did not have a
* mapping.
* @exception NullPointerException if key is null.
*/
remove(key: any): V;
}
}
export declare namespace java.util {
/**
* A collection designed for holding elements prior to processing. Deque
*
* @param Comparator<String> compareString = Comparators.natural()
*
* @return {*} the natural Comparator
*/
static natural