QueryParams

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def add(other: QueryParams): QueryParams

Add multiple key/value pairs

def add(kvPairs: (String, String)*): QueryParams

Add multiple key/value pairs

def add(key: String, value: String): QueryParams

Add a key/value pair

def allKeys: Set[String]

The unique set of keys with or without values

def apply(idx: Int): (String, String)

def apply(key: String): Seq[String]

Returns all values for the given key or throws a NoSuchElementException if the key doesn't exists.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(elem: (String, String)): Boolean

Check for key/value pair existence

def contains(key: String, value: String): Boolean

Check for key/value pair existence

def contains(key: String): Boolean

Check for key existence

final def eq(arg0: AnyRef): Boolean

def equals(obj: Any): Boolean

def filter(f: ((String, String)) ⇒ Boolean): QueryParams

def filterKeys(f: (String) ⇒ Boolean): QueryParams

def filterNot(f: ((String, String)) ⇒ Boolean): QueryParams

def filterValues(f: (String) ⇒ Boolean): QueryParams

def first(key: String): String

Returns the first non-null value for the given key or throws a NoSuchElementException if none exists.

def firstNonBlank(key: String): String

Returns the first non-blank value for the given key or throws a NoSuchElementException if none exists.

def foreach[U](f: ((String, String)) ⇒ U): Unit

def get(key: String): Seq[String]

Returns all values for the given key.

final def getClass(): Class[_]

def getFirst(key: String): Option[String]

Optionally Returns the first non-null value for the given key

def getFirstNonBlank(key: String): Option[String]

Optionally Returns the first non-blank value for the given key

def getNonBlank(key: String): Seq[String]

Returns all non-blank values for the given key.

def hasKey(key: String): Boolean

Returns true if there is a matching key (which doesn't need to have a value)

def hasKeyWithNonBlankValue(key: String): Boolean

Returns true if there is a matching key (which also has a non-blank value)

def hasKeyWithValue(key: String, value: String): Boolean

Returns true if there is a matching key which has the given value

def hasKeyWithValue(key: String): Boolean

Returns true if there is a matching key (which also has a value)

def hashCode(): Int

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def keysWithNonBlankValues: Set[String]

The unique set of keys with non-blank values

def keysWithValues: Set[String]

The unique set of keys with non-null values (blank is a valid value)

def keysWithoutValues: Set[String]

The unique set of keys without values

def length: Int

def map(f: ((String, String)) ⇒ (String, String)): QueryParams

def mapKeys(f: (String) ⇒ String): QueryParams

def mapValues(f: (String) ⇒ String): QueryParams

final def ne(arg0: AnyRef): Boolean

def nonBlank(key: String): Seq[String]

Returns all non-blank values for the given key or throws a NoSuchElementException if the key doesn't have non-null values.

def nonEmpty: Boolean

def nonNull(key: String): Seq[String]

Returns all non-null values for the given key or throws a NoSuchElementException if the key doesn't have non-null values.

final def notify(): Unit

final def notifyAll(): Unit

def prettyString: String

def remove(keys: String*): QueryParams

Remove a key/value pair based on the key

def replace(key: String, value: String): QueryParams

Replaces the entry for the given key only if it was previously mapped to some value.

def sorted: QueryParams

final def synchronized[T0](arg0: ⇒ T0): T0

def toMap: Map[String, Seq[String]]

Convert to a Map[String, Seq[String]]

def toQueryString(): String

Create a valid query string using the current parameters (everything after the ?).

def toSeq: Seq[(String, String)]

def toString(): String

An alias for toQueryString

def updated(kvPairs: (String, String)*): QueryParams

Update multiple key/value pairs

def updated(other: QueryParams): QueryParams

Update multiple key/value pairs

def updated(key: String, value: String): QueryParams

If the key doesn't exist then add it, otherwise replace the first occurance of the key with the new value and remove any other values.

def updated(key: String): QueryParams

Make sure the key (without a value) exists

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

def withLowerKeys: QueryParams

Convert all keys to lower case

def withPrefixedKeys(prefix: String): QueryParams

Add a prefix to each key

def withoutBlankValues(): QueryParams

Remove any params with blank values

def finalize(): Unit