From b24c9a0e55485a09a2b7cee573ab360cd1687681 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 4 Nov 2024 21:51:05 +0000 Subject: [PATCH] chore: rebuild project due to codegen change (#56) --- .../okhttp/OnebusawaySdkOkHttpClient.kt | 34 +++++- .../okhttp/OnebusawaySdkOkHttpClientAsync.kt | 34 +++++- .../org/onebusaway/core/ClientOptions.kt | 32 ++++- .../models/AgenciesWithCoverageListParams.kt | 108 +++++++++++------ .../onebusaway/models/AgencyRetrieveParams.kt | 110 ++++++++++++------ .../models/ArrivalAndDepartureListParams.kt | 110 ++++++++++++------ .../ArrivalAndDepartureRetrieveParams.kt | 110 ++++++++++++------ .../onebusaway/models/BlockRetrieveParams.kt | 110 ++++++++++++------ .../onebusaway/models/ConfigRetrieveParams.kt | 108 +++++++++++------ .../models/CurrentTimeRetrieveParams.kt | 108 +++++++++++------ .../ReportProblemWithStopRetrieveParams.kt | 110 ++++++++++++------ .../ReportProblemWithTripRetrieveParams.kt | 110 ++++++++++++------ .../models/RouteIdsForAgencyListParams.kt | 110 ++++++++++++------ .../onebusaway/models/RouteRetrieveParams.kt | 110 ++++++++++++------ .../models/RoutesForAgencyListParams.kt | 110 ++++++++++++------ .../models/RoutesForLocationListParams.kt | 108 +++++++++++------ .../models/ScheduleForRouteRetrieveParams.kt | 110 ++++++++++++------ .../models/ScheduleForStopRetrieveParams.kt | 110 ++++++++++++------ .../models/SearchForRouteListParams.kt | 108 +++++++++++------ .../models/SearchForStopListParams.kt | 108 +++++++++++------ .../onebusaway/models/ShapeRetrieveParams.kt | 110 ++++++++++++------ .../models/StopIdsForAgencyListParams.kt | 110 ++++++++++++------ .../onebusaway/models/StopRetrieveParams.kt | 110 ++++++++++++------ .../models/StopsForLocationListParams.kt | 108 +++++++++++------ .../models/StopsForRouteListParams.kt | 110 ++++++++++++------ .../models/TripDetailRetrieveParams.kt | 110 ++++++++++++------ .../models/TripForVehicleRetrieveParams.kt | 110 ++++++++++++------ .../onebusaway/models/TripRetrieveParams.kt | 110 ++++++++++++------ .../models/TripsForLocationListParams.kt | 108 +++++++++++------ .../models/TripsForRouteListParams.kt | 110 ++++++++++++------ .../models/VehiclesForAgencyListParams.kt | 110 ++++++++++++------ 31 files changed, 2214 insertions(+), 950 deletions(-) diff --git a/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClient.kt b/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClient.kt index ca72b00..416e75c 100644 --- a/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClient.kt +++ b/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClient.kt @@ -50,7 +50,21 @@ class OnebusawaySdkOkHttpClient private constructor() { clientOptions.putAllHeaders(headers) } - fun removeHeader(name: String) = apply { clientOptions.removeHeader(name) } + fun replaceHeaders(name: String, value: String) = apply { + clientOptions.replaceHeaders(name, value) + } + + fun replaceHeaders(name: String, values: Iterable) = apply { + clientOptions.replaceHeaders(name, values) + } + + fun replaceAllHeaders(headers: Map>) = apply { + clientOptions.replaceAllHeaders(headers) + } + + fun removeHeaders(name: String) = apply { clientOptions.removeHeaders(name) } + + fun removeAllHeaders(names: Set) = apply { clientOptions.removeAllHeaders(names) } fun queryParams(queryParams: Map>) = apply { clientOptions.queryParams(queryParams) @@ -68,7 +82,23 @@ class OnebusawaySdkOkHttpClient private constructor() { clientOptions.putAllQueryParams(queryParams) } - fun removeQueryParam(key: String) = apply { clientOptions.removeQueryParam(key) } + fun replaceQueryParams(key: String, value: String) = apply { + clientOptions.replaceQueryParams(key, value) + } + + fun replaceQueryParams(key: String, values: Iterable) = apply { + clientOptions.replaceQueryParams(key, values) + } + + fun replaceAllQueryParams(queryParams: Map>) = apply { + clientOptions.replaceAllQueryParams(queryParams) + } + + fun removeQueryParams(key: String) = apply { clientOptions.removeQueryParams(key) } + + fun removeAllQueryParams(keys: Set) = apply { + clientOptions.removeAllQueryParams(keys) + } fun timeout(timeout: Duration) = apply { this.timeout = timeout } diff --git a/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClientAsync.kt b/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClientAsync.kt index c1ffde7..8b53572 100644 --- a/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClientAsync.kt +++ b/onebusaway-sdk-kotlin-client-okhttp/src/main/kotlin/org/onebusaway/client/okhttp/OnebusawaySdkOkHttpClientAsync.kt @@ -50,7 +50,21 @@ class OnebusawaySdkOkHttpClientAsync private constructor() { clientOptions.putAllHeaders(headers) } - fun removeHeader(name: String) = apply { clientOptions.removeHeader(name) } + fun replaceHeaders(name: String, value: String) = apply { + clientOptions.replaceHeaders(name, value) + } + + fun replaceHeaders(name: String, values: Iterable) = apply { + clientOptions.replaceHeaders(name, values) + } + + fun replaceAllHeaders(headers: Map>) = apply { + clientOptions.replaceAllHeaders(headers) + } + + fun removeHeaders(name: String) = apply { clientOptions.removeHeaders(name) } + + fun removeAllHeaders(names: Set) = apply { clientOptions.removeAllHeaders(names) } fun queryParams(queryParams: Map>) = apply { clientOptions.queryParams(queryParams) @@ -68,7 +82,23 @@ class OnebusawaySdkOkHttpClientAsync private constructor() { clientOptions.putAllQueryParams(queryParams) } - fun removeQueryParam(key: String) = apply { clientOptions.removeQueryParam(key) } + fun replaceQueryParams(key: String, value: String) = apply { + clientOptions.replaceQueryParams(key, value) + } + + fun replaceQueryParams(key: String, values: Iterable) = apply { + clientOptions.replaceQueryParams(key, values) + } + + fun replaceAllQueryParams(queryParams: Map>) = apply { + clientOptions.replaceAllQueryParams(queryParams) + } + + fun removeQueryParams(key: String) = apply { clientOptions.removeQueryParams(key) } + + fun removeAllQueryParams(keys: Set) = apply { + clientOptions.removeAllQueryParams(keys) + } fun timeout(timeout: Duration) = apply { this.timeout = timeout } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/core/ClientOptions.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/core/ClientOptions.kt index 99d5361..44c909e 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/core/ClientOptions.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/core/ClientOptions.kt @@ -82,7 +82,21 @@ private constructor( headers.forEach(::putHeaders) } - fun removeHeader(name: String) = apply { headers.removeAll(name) } + fun replaceHeaders(name: String, value: String) = apply { + headers.replaceValues(name, listOf(value)) + } + + fun replaceHeaders(name: String, values: Iterable) = apply { + headers.replaceValues(name, values) + } + + fun replaceAllHeaders(headers: Map>) = apply { + headers.forEach(::replaceHeaders) + } + + fun removeHeaders(name: String) = apply { headers.removeAll(name) } + + fun removeAllHeaders(names: Set) = apply { names.forEach(::removeHeaders) } fun queryParams(queryParams: Map>) = apply { this.queryParams.clear() @@ -99,7 +113,21 @@ private constructor( queryParams.forEach(::putQueryParams) } - fun removeQueryParam(key: String) = apply { queryParams.removeAll(key) } + fun replaceQueryParams(key: String, value: String) = apply { + queryParams.replaceValues(key, listOf(value)) + } + + fun replaceQueryParams(key: String, values: Iterable) = apply { + queryParams.replaceValues(key, values) + } + + fun replaceAllQueryParams(queryParams: Map>) = apply { + queryParams.forEach(::replaceQueryParams) + } + + fun removeQueryParams(key: String) = apply { queryParams.removeAll(key) } + + fun removeAllQueryParams(keys: Set) = apply { keys.forEach(::removeQueryParams) } fun responseValidation(responseValidation: Boolean) = apply { this.responseValidation = responseValidation diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgenciesWithCoverageListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgenciesWithCoverageListParams.kt index ed5663e..076b345 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgenciesWithCoverageListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgenciesWithCoverageListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -9,32 +11,32 @@ import org.onebusaway.models.* class AgenciesWithCoverageListParams constructor( - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): Map> = additionalQueryParams fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is AgenciesWithCoverageListParams && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is AgenciesWithCoverageListParams && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "AgenciesWithCoverageListParams{additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "AgenciesWithCoverageListParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -46,58 +48,98 @@ constructor( @NoAutoDetect class Builder { - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(agenciesWithCoverageListParams: AgenciesWithCoverageListParams) = apply { - additionalQueryParams(agenciesWithCoverageListParams.additionalQueryParams) additionalHeaders(agenciesWithCoverageListParams.additionalHeaders) + additionalQueryParams(agenciesWithCoverageListParams.additionalQueryParams) } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): AgenciesWithCoverageListParams = AgenciesWithCoverageListParams( - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable() + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable() ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgencyRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgencyRetrieveParams.kt index ff12358..2c5d719 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgencyRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/AgencyRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class AgencyRetrieveParams constructor( private val agencyId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun agencyId(): String = agencyId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> agencyId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is AgencyRetrieveParams && this.agencyId == other.agencyId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is AgencyRetrieveParams && this.agencyId == other.agencyId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(agencyId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(agencyId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "AgencyRetrieveParams{agencyId=$agencyId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "AgencyRetrieveParams{agencyId=$agencyId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var agencyId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(agencyRetrieveParams: AgencyRetrieveParams) = apply { this.agencyId = agencyRetrieveParams.agencyId - additionalQueryParams(agencyRetrieveParams.additionalQueryParams) additionalHeaders(agencyRetrieveParams.additionalHeaders) + additionalQueryParams(agencyRetrieveParams.additionalQueryParams) } fun agencyId(agencyId: String) = apply { this.agencyId = agencyId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): AgencyRetrieveParams = AgencyRetrieveParams( checkNotNull(agencyId) { "`agencyId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureListParams.kt index 443f1b2..3d3b09b 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.time.OffsetDateTime import java.time.format.DateTimeFormatter import java.util.Objects @@ -15,8 +17,8 @@ constructor( private val minutesAfter: Long?, private val minutesBefore: Long?, private val time: OffsetDateTime?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun stopId(): String = stopId @@ -27,6 +29,8 @@ constructor( fun time(): OffsetDateTime? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.minutesAfter?.let { params.put("minutesAfter", listOf(it.toString())) } @@ -38,8 +42,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> stopId @@ -47,24 +49,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ArrivalAndDepartureListParams && this.stopId == other.stopId && this.minutesAfter == other.minutesAfter && this.minutesBefore == other.minutesBefore && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ArrivalAndDepartureListParams && this.stopId == other.stopId && this.minutesAfter == other.minutesAfter && this.minutesBefore == other.minutesBefore && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(stopId, minutesAfter, minutesBefore, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(stopId, minutesAfter, minutesBefore, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ArrivalAndDepartureListParams{stopId=$stopId, minutesAfter=$minutesAfter, minutesBefore=$minutesBefore, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ArrivalAndDepartureListParams{stopId=$stopId, minutesAfter=$minutesAfter, minutesBefore=$minutesBefore, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -80,16 +82,16 @@ constructor( private var minutesAfter: Long? = null private var minutesBefore: Long? = null private var time: OffsetDateTime? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(arrivalAndDepartureListParams: ArrivalAndDepartureListParams) = apply { this.stopId = arrivalAndDepartureListParams.stopId this.minutesAfter = arrivalAndDepartureListParams.minutesAfter this.minutesBefore = arrivalAndDepartureListParams.minutesBefore this.time = arrivalAndDepartureListParams.time - additionalQueryParams(arrivalAndDepartureListParams.additionalQueryParams) additionalHeaders(arrivalAndDepartureListParams.additionalHeaders) + additionalQueryParams(arrivalAndDepartureListParams.additionalQueryParams) } fun stopId(stopId: String) = apply { this.stopId = stopId } @@ -103,45 +105,79 @@ constructor( /** The specific time for querying the system status. */ fun time(time: OffsetDateTime) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ArrivalAndDepartureListParams = ArrivalAndDepartureListParams( @@ -149,8 +185,14 @@ constructor( minutesAfter, minutesBefore, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureRetrieveParams.kt index d97d9c7..27ae479 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ArrivalAndDepartureRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -15,8 +17,8 @@ constructor( private val stopSequence: Long?, private val time: Long?, private val vehicleId: String?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun stopId(): String = stopId @@ -31,6 +33,8 @@ constructor( fun vehicleId(): String? = vehicleId + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.serviceDate.let { params.put("serviceDate", listOf(it.toString())) } @@ -42,8 +46,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> stopId @@ -51,24 +53,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ArrivalAndDepartureRetrieveParams && this.stopId == other.stopId && this.serviceDate == other.serviceDate && this.tripId == other.tripId && this.stopSequence == other.stopSequence && this.time == other.time && this.vehicleId == other.vehicleId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ArrivalAndDepartureRetrieveParams && this.stopId == other.stopId && this.serviceDate == other.serviceDate && this.tripId == other.tripId && this.stopSequence == other.stopSequence && this.time == other.time && this.vehicleId == other.vehicleId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(stopId, serviceDate, tripId, stopSequence, time, vehicleId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(stopId, serviceDate, tripId, stopSequence, time, vehicleId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ArrivalAndDepartureRetrieveParams{stopId=$stopId, serviceDate=$serviceDate, tripId=$tripId, stopSequence=$stopSequence, time=$time, vehicleId=$vehicleId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ArrivalAndDepartureRetrieveParams{stopId=$stopId, serviceDate=$serviceDate, tripId=$tripId, stopSequence=$stopSequence, time=$time, vehicleId=$vehicleId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -86,8 +88,8 @@ constructor( private var stopSequence: Long? = null private var time: Long? = null private var vehicleId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(arrivalAndDepartureRetrieveParams: ArrivalAndDepartureRetrieveParams) = apply { @@ -97,8 +99,8 @@ constructor( this.stopSequence = arrivalAndDepartureRetrieveParams.stopSequence this.time = arrivalAndDepartureRetrieveParams.time this.vehicleId = arrivalAndDepartureRetrieveParams.vehicleId - additionalQueryParams(arrivalAndDepartureRetrieveParams.additionalQueryParams) additionalHeaders(arrivalAndDepartureRetrieveParams.additionalHeaders) + additionalQueryParams(arrivalAndDepartureRetrieveParams.additionalQueryParams) } fun stopId(stopId: String) = apply { this.stopId = stopId } @@ -113,45 +115,79 @@ constructor( fun vehicleId(vehicleId: String) = apply { this.vehicleId = vehicleId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ArrivalAndDepartureRetrieveParams = ArrivalAndDepartureRetrieveParams( @@ -161,8 +197,14 @@ constructor( stopSequence, time, vehicleId, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/BlockRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/BlockRetrieveParams.kt index d3eb948..1d19529 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/BlockRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/BlockRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class BlockRetrieveParams constructor( private val blockId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun blockId(): String = blockId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> blockId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is BlockRetrieveParams && this.blockId == other.blockId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is BlockRetrieveParams && this.blockId == other.blockId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(blockId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(blockId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "BlockRetrieveParams{blockId=$blockId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "BlockRetrieveParams{blockId=$blockId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var blockId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(blockRetrieveParams: BlockRetrieveParams) = apply { this.blockId = blockRetrieveParams.blockId - additionalQueryParams(blockRetrieveParams.additionalQueryParams) additionalHeaders(blockRetrieveParams.additionalHeaders) + additionalQueryParams(blockRetrieveParams.additionalQueryParams) } fun blockId(blockId: String) = apply { this.blockId = blockId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): BlockRetrieveParams = BlockRetrieveParams( checkNotNull(blockId) { "`blockId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ConfigRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ConfigRetrieveParams.kt index e22da98..3be181e 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ConfigRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ConfigRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -9,32 +11,32 @@ import org.onebusaway.models.* class ConfigRetrieveParams constructor( - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): Map> = additionalQueryParams fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ConfigRetrieveParams && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ConfigRetrieveParams && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ConfigRetrieveParams{additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ConfigRetrieveParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -46,58 +48,98 @@ constructor( @NoAutoDetect class Builder { - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(configRetrieveParams: ConfigRetrieveParams) = apply { - additionalQueryParams(configRetrieveParams.additionalQueryParams) additionalHeaders(configRetrieveParams.additionalHeaders) + additionalQueryParams(configRetrieveParams.additionalQueryParams) } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ConfigRetrieveParams = ConfigRetrieveParams( - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable() + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable() ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/CurrentTimeRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/CurrentTimeRetrieveParams.kt index f9246b8..e9de13a 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/CurrentTimeRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/CurrentTimeRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -9,32 +11,32 @@ import org.onebusaway.models.* class CurrentTimeRetrieveParams constructor( - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders - fun _additionalQueryParams(): Map> = additionalQueryParams + internal fun getQueryParams(): Map> = additionalQueryParams fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is CurrentTimeRetrieveParams && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is CurrentTimeRetrieveParams && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "CurrentTimeRetrieveParams{additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "CurrentTimeRetrieveParams{additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -46,58 +48,98 @@ constructor( @NoAutoDetect class Builder { - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(currentTimeRetrieveParams: CurrentTimeRetrieveParams) = apply { - additionalQueryParams(currentTimeRetrieveParams.additionalQueryParams) additionalHeaders(currentTimeRetrieveParams.additionalHeaders) + additionalQueryParams(currentTimeRetrieveParams.additionalQueryParams) } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): CurrentTimeRetrieveParams = CurrentTimeRetrieveParams( - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable() + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable() ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithStopRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithStopRetrieveParams.kt index 94aeb51..a94a910 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithStopRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithStopRetrieveParams.kt @@ -3,6 +3,8 @@ package org.onebusaway.models import com.fasterxml.jackson.annotation.JsonCreator +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.Enum import org.onebusaway.core.JsonField @@ -20,8 +22,8 @@ constructor( private val userLat: Double?, private val userLocationAccuracy: Double?, private val userLon: Double?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun stopId(): String = stopId @@ -36,6 +38,8 @@ constructor( fun userLon(): Double? = userLon + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.code?.let { params.put("code", listOf(it.toString())) } @@ -47,8 +51,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> stopId @@ -56,24 +58,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ReportProblemWithStopRetrieveParams && this.stopId == other.stopId && this.code == other.code && this.userComment == other.userComment && this.userLat == other.userLat && this.userLocationAccuracy == other.userLocationAccuracy && this.userLon == other.userLon && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ReportProblemWithStopRetrieveParams && this.stopId == other.stopId && this.code == other.code && this.userComment == other.userComment && this.userLat == other.userLat && this.userLocationAccuracy == other.userLocationAccuracy && this.userLon == other.userLon && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(stopId, code, userComment, userLat, userLocationAccuracy, userLon, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(stopId, code, userComment, userLat, userLocationAccuracy, userLon, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ReportProblemWithStopRetrieveParams{stopId=$stopId, code=$code, userComment=$userComment, userLat=$userLat, userLocationAccuracy=$userLocationAccuracy, userLon=$userLon, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ReportProblemWithStopRetrieveParams{stopId=$stopId, code=$code, userComment=$userComment, userLat=$userLat, userLocationAccuracy=$userLocationAccuracy, userLon=$userLon, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -91,8 +93,8 @@ constructor( private var userLat: Double? = null private var userLocationAccuracy: Double? = null private var userLon: Double? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from( reportProblemWithStopRetrieveParams: ReportProblemWithStopRetrieveParams @@ -103,8 +105,8 @@ constructor( this.userLat = reportProblemWithStopRetrieveParams.userLat this.userLocationAccuracy = reportProblemWithStopRetrieveParams.userLocationAccuracy this.userLon = reportProblemWithStopRetrieveParams.userLon - additionalQueryParams(reportProblemWithStopRetrieveParams.additionalQueryParams) additionalHeaders(reportProblemWithStopRetrieveParams.additionalHeaders) + additionalQueryParams(reportProblemWithStopRetrieveParams.additionalQueryParams) } fun stopId(stopId: String) = apply { this.stopId = stopId } @@ -126,45 +128,79 @@ constructor( /** The reporting user’s current longitude */ fun userLon(userLon: Double) = apply { this.userLon = userLon } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ReportProblemWithStopRetrieveParams = ReportProblemWithStopRetrieveParams( @@ -174,8 +210,14 @@ constructor( userLat, userLocationAccuracy, userLon, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithTripRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithTripRetrieveParams.kt index 0a779b5..0e352ee 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithTripRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ReportProblemWithTripRetrieveParams.kt @@ -3,6 +3,8 @@ package org.onebusaway.models import com.fasterxml.jackson.annotation.JsonCreator +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.Enum import org.onebusaway.core.JsonField @@ -25,8 +27,8 @@ constructor( private val userOnVehicle: Boolean?, private val userVehicleNumber: String?, private val vehicleId: String?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun tripId(): String = tripId @@ -51,6 +53,8 @@ constructor( fun vehicleId(): String? = vehicleId + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.code?.let { params.put("code", listOf(it.toString())) } @@ -67,8 +71,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> tripId @@ -76,24 +78,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ReportProblemWithTripRetrieveParams && this.tripId == other.tripId && this.code == other.code && this.serviceDate == other.serviceDate && this.stopId == other.stopId && this.userComment == other.userComment && this.userLat == other.userLat && this.userLocationAccuracy == other.userLocationAccuracy && this.userLon == other.userLon && this.userOnVehicle == other.userOnVehicle && this.userVehicleNumber == other.userVehicleNumber && this.vehicleId == other.vehicleId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ReportProblemWithTripRetrieveParams && this.tripId == other.tripId && this.code == other.code && this.serviceDate == other.serviceDate && this.stopId == other.stopId && this.userComment == other.userComment && this.userLat == other.userLat && this.userLocationAccuracy == other.userLocationAccuracy && this.userLon == other.userLon && this.userOnVehicle == other.userOnVehicle && this.userVehicleNumber == other.userVehicleNumber && this.vehicleId == other.vehicleId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(tripId, code, serviceDate, stopId, userComment, userLat, userLocationAccuracy, userLon, userOnVehicle, userVehicleNumber, vehicleId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(tripId, code, serviceDate, stopId, userComment, userLat, userLocationAccuracy, userLon, userOnVehicle, userVehicleNumber, vehicleId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ReportProblemWithTripRetrieveParams{tripId=$tripId, code=$code, serviceDate=$serviceDate, stopId=$stopId, userComment=$userComment, userLat=$userLat, userLocationAccuracy=$userLocationAccuracy, userLon=$userLon, userOnVehicle=$userOnVehicle, userVehicleNumber=$userVehicleNumber, vehicleId=$vehicleId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ReportProblemWithTripRetrieveParams{tripId=$tripId, code=$code, serviceDate=$serviceDate, stopId=$stopId, userComment=$userComment, userLat=$userLat, userLocationAccuracy=$userLocationAccuracy, userLon=$userLon, userOnVehicle=$userOnVehicle, userVehicleNumber=$userVehicleNumber, vehicleId=$vehicleId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -116,8 +118,8 @@ constructor( private var userOnVehicle: Boolean? = null private var userVehicleNumber: String? = null private var vehicleId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from( reportProblemWithTripRetrieveParams: ReportProblemWithTripRetrieveParams @@ -133,8 +135,8 @@ constructor( this.userOnVehicle = reportProblemWithTripRetrieveParams.userOnVehicle this.userVehicleNumber = reportProblemWithTripRetrieveParams.userVehicleNumber this.vehicleId = reportProblemWithTripRetrieveParams.vehicleId - additionalQueryParams(reportProblemWithTripRetrieveParams.additionalQueryParams) additionalHeaders(reportProblemWithTripRetrieveParams.additionalHeaders) + additionalQueryParams(reportProblemWithTripRetrieveParams.additionalQueryParams) } fun tripId(tripId: String) = apply { this.tripId = tripId } @@ -173,45 +175,79 @@ constructor( /** The vehicle actively serving the trip */ fun vehicleId(vehicleId: String) = apply { this.vehicleId = vehicleId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ReportProblemWithTripRetrieveParams = ReportProblemWithTripRetrieveParams( @@ -226,8 +262,14 @@ constructor( userOnVehicle, userVehicleNumber, vehicleId, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteIdsForAgencyListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteIdsForAgencyListParams.kt index 8bdec65..619fbd9 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteIdsForAgencyListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteIdsForAgencyListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class RouteIdsForAgencyListParams constructor( private val agencyId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun agencyId(): String = agencyId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> agencyId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is RouteIdsForAgencyListParams && this.agencyId == other.agencyId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is RouteIdsForAgencyListParams && this.agencyId == other.agencyId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(agencyId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(agencyId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "RouteIdsForAgencyListParams{agencyId=$agencyId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "RouteIdsForAgencyListParams{agencyId=$agencyId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var agencyId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(routeIdsForAgencyListParams: RouteIdsForAgencyListParams) = apply { this.agencyId = routeIdsForAgencyListParams.agencyId - additionalQueryParams(routeIdsForAgencyListParams.additionalQueryParams) additionalHeaders(routeIdsForAgencyListParams.additionalHeaders) + additionalQueryParams(routeIdsForAgencyListParams.additionalQueryParams) } fun agencyId(agencyId: String) = apply { this.agencyId = agencyId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): RouteIdsForAgencyListParams = RouteIdsForAgencyListParams( checkNotNull(agencyId) { "`agencyId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteRetrieveParams.kt index f80efba..9a81c5c 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RouteRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class RouteRetrieveParams constructor( private val routeId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun routeId(): String = routeId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> routeId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is RouteRetrieveParams && this.routeId == other.routeId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is RouteRetrieveParams && this.routeId == other.routeId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(routeId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(routeId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "RouteRetrieveParams{routeId=$routeId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "RouteRetrieveParams{routeId=$routeId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var routeId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(routeRetrieveParams: RouteRetrieveParams) = apply { this.routeId = routeRetrieveParams.routeId - additionalQueryParams(routeRetrieveParams.additionalQueryParams) additionalHeaders(routeRetrieveParams.additionalHeaders) + additionalQueryParams(routeRetrieveParams.additionalQueryParams) } fun routeId(routeId: String) = apply { this.routeId = routeId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): RouteRetrieveParams = RouteRetrieveParams( checkNotNull(routeId) { "`routeId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForAgencyListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForAgencyListParams.kt index f5e3689..c6223a9 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForAgencyListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForAgencyListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class RoutesForAgencyListParams constructor( private val agencyId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun agencyId(): String = agencyId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> agencyId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is RoutesForAgencyListParams && this.agencyId == other.agencyId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is RoutesForAgencyListParams && this.agencyId == other.agencyId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(agencyId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(agencyId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "RoutesForAgencyListParams{agencyId=$agencyId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "RoutesForAgencyListParams{agencyId=$agencyId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var agencyId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(routesForAgencyListParams: RoutesForAgencyListParams) = apply { this.agencyId = routesForAgencyListParams.agencyId - additionalQueryParams(routesForAgencyListParams.additionalQueryParams) additionalHeaders(routesForAgencyListParams.additionalHeaders) + additionalQueryParams(routesForAgencyListParams.additionalQueryParams) } fun agencyId(agencyId: String) = apply { this.agencyId = agencyId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): RoutesForAgencyListParams = RoutesForAgencyListParams( checkNotNull(agencyId) { "`agencyId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForLocationListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForLocationListParams.kt index 94df1ff..44323e5 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForLocationListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/RoutesForLocationListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -15,8 +17,8 @@ constructor( private val lonSpan: Double?, private val query: String?, private val radius: Double?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun lat(): Double = lat @@ -31,6 +33,8 @@ constructor( fun radius(): Double? = radius + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.lat.let { params.put("lat", listOf(it.toString())) } @@ -43,26 +47,24 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Map> = additionalHeaders fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders - override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is RoutesForLocationListParams && this.lat == other.lat && this.lon == other.lon && this.latSpan == other.latSpan && this.lonSpan == other.lonSpan && this.query == other.query && this.radius == other.radius && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is RoutesForLocationListParams && this.lat == other.lat && this.lon == other.lon && this.latSpan == other.latSpan && this.lonSpan == other.lonSpan && this.query == other.query && this.radius == other.radius && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(lat, lon, latSpan, lonSpan, query, radius, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(lat, lon, latSpan, lonSpan, query, radius, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "RoutesForLocationListParams{lat=$lat, lon=$lon, latSpan=$latSpan, lonSpan=$lonSpan, query=$query, radius=$radius, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "RoutesForLocationListParams{lat=$lat, lon=$lon, latSpan=$latSpan, lonSpan=$lonSpan, query=$query, radius=$radius, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -80,8 +82,8 @@ constructor( private var lonSpan: Double? = null private var query: String? = null private var radius: Double? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(routesForLocationListParams: RoutesForLocationListParams) = apply { this.lat = routesForLocationListParams.lat @@ -90,8 +92,8 @@ constructor( this.lonSpan = routesForLocationListParams.lonSpan this.query = routesForLocationListParams.query this.radius = routesForLocationListParams.radius - additionalQueryParams(routesForLocationListParams.additionalQueryParams) additionalHeaders(routesForLocationListParams.additionalHeaders) + additionalQueryParams(routesForLocationListParams.additionalQueryParams) } fun lat(lat: Double) = apply { this.lat = lat } @@ -106,45 +108,79 @@ constructor( fun radius(radius: Double) = apply { this.radius = radius } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): RoutesForLocationListParams = RoutesForLocationListParams( @@ -154,8 +190,14 @@ constructor( lonSpan, query, radius, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForRouteRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForRouteRetrieveParams.kt index 5ed3993..1ee2212 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForRouteRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForRouteRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.time.LocalDate import java.util.Objects import org.onebusaway.core.NoAutoDetect @@ -12,14 +14,16 @@ class ScheduleForRouteRetrieveParams constructor( private val routeId: String, private val date: LocalDate?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun routeId(): String = routeId fun date(): LocalDate? = date + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.date?.let { params.put("date", listOf(it.toString())) } @@ -27,8 +31,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> routeId @@ -36,24 +38,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ScheduleForRouteRetrieveParams && this.routeId == other.routeId && this.date == other.date && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ScheduleForRouteRetrieveParams && this.routeId == other.routeId && this.date == other.date && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(routeId, date, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(routeId, date, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ScheduleForRouteRetrieveParams{routeId=$routeId, date=$date, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ScheduleForRouteRetrieveParams{routeId=$routeId, date=$date, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -67,14 +69,14 @@ constructor( private var routeId: String? = null private var date: LocalDate? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(scheduleForRouteRetrieveParams: ScheduleForRouteRetrieveParams) = apply { this.routeId = scheduleForRouteRetrieveParams.routeId this.date = scheduleForRouteRetrieveParams.date - additionalQueryParams(scheduleForRouteRetrieveParams.additionalQueryParams) additionalHeaders(scheduleForRouteRetrieveParams.additionalHeaders) + additionalQueryParams(scheduleForRouteRetrieveParams.additionalQueryParams) } fun routeId(routeId: String) = apply { this.routeId = routeId } @@ -85,52 +87,92 @@ constructor( */ fun date(date: LocalDate) = apply { this.date = date } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ScheduleForRouteRetrieveParams = ScheduleForRouteRetrieveParams( checkNotNull(routeId) { "`routeId` is required but was not set" }, date, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForStopRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForStopRetrieveParams.kt index a80bffd..a192a2c 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForStopRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ScheduleForStopRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.time.LocalDate import java.util.Objects import org.onebusaway.core.NoAutoDetect @@ -12,14 +14,16 @@ class ScheduleForStopRetrieveParams constructor( private val stopId: String, private val date: LocalDate?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun stopId(): String = stopId fun date(): LocalDate? = date + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.date?.let { params.put("date", listOf(it.toString())) } @@ -27,8 +31,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> stopId @@ -36,24 +38,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ScheduleForStopRetrieveParams && this.stopId == other.stopId && this.date == other.date && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ScheduleForStopRetrieveParams && this.stopId == other.stopId && this.date == other.date && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(stopId, date, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(stopId, date, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ScheduleForStopRetrieveParams{stopId=$stopId, date=$date, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ScheduleForStopRetrieveParams{stopId=$stopId, date=$date, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -67,14 +69,14 @@ constructor( private var stopId: String? = null private var date: LocalDate? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(scheduleForStopRetrieveParams: ScheduleForStopRetrieveParams) = apply { this.stopId = scheduleForStopRetrieveParams.stopId this.date = scheduleForStopRetrieveParams.date - additionalQueryParams(scheduleForStopRetrieveParams.additionalQueryParams) additionalHeaders(scheduleForStopRetrieveParams.additionalHeaders) + additionalQueryParams(scheduleForStopRetrieveParams.additionalQueryParams) } fun stopId(stopId: String) = apply { this.stopId = stopId } @@ -85,52 +87,92 @@ constructor( */ fun date(date: LocalDate) = apply { this.date = date } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ScheduleForStopRetrieveParams = ScheduleForStopRetrieveParams( checkNotNull(stopId) { "`stopId` is required but was not set" }, date, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForRouteListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForRouteListParams.kt index 1b161d4..f0fff3c 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForRouteListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForRouteListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -11,14 +13,16 @@ class SearchForRouteListParams constructor( private val input: String, private val maxCount: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun input(): String = input fun maxCount(): Long? = maxCount + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.input.let { params.put("input", listOf(it.toString())) } @@ -27,26 +31,24 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Map> = additionalHeaders fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders - override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is SearchForRouteListParams && this.input == other.input && this.maxCount == other.maxCount && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is SearchForRouteListParams && this.input == other.input && this.maxCount == other.maxCount && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(input, maxCount, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(input, maxCount, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "SearchForRouteListParams{input=$input, maxCount=$maxCount, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "SearchForRouteListParams{input=$input, maxCount=$maxCount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -60,14 +62,14 @@ constructor( private var input: String? = null private var maxCount: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(searchForRouteListParams: SearchForRouteListParams) = apply { this.input = searchForRouteListParams.input this.maxCount = searchForRouteListParams.maxCount - additionalQueryParams(searchForRouteListParams.additionalQueryParams) additionalHeaders(searchForRouteListParams.additionalHeaders) + additionalQueryParams(searchForRouteListParams.additionalQueryParams) } /** The string to search for. */ @@ -76,52 +78,92 @@ constructor( /** The max number of results to return. Defaults to 20. */ fun maxCount(maxCount: Long) = apply { this.maxCount = maxCount } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): SearchForRouteListParams = SearchForRouteListParams( checkNotNull(input) { "`input` is required but was not set" }, maxCount, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForStopListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForStopListParams.kt index 8627f99..5ca48a8 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForStopListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/SearchForStopListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -11,14 +13,16 @@ class SearchForStopListParams constructor( private val input: String, private val maxCount: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun input(): String = input fun maxCount(): Long? = maxCount + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.input.let { params.put("input", listOf(it.toString())) } @@ -27,26 +31,24 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Map> = additionalHeaders fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders - override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is SearchForStopListParams && this.input == other.input && this.maxCount == other.maxCount && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is SearchForStopListParams && this.input == other.input && this.maxCount == other.maxCount && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(input, maxCount, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(input, maxCount, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "SearchForStopListParams{input=$input, maxCount=$maxCount, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "SearchForStopListParams{input=$input, maxCount=$maxCount, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -60,14 +62,14 @@ constructor( private var input: String? = null private var maxCount: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(searchForStopListParams: SearchForStopListParams) = apply { this.input = searchForStopListParams.input this.maxCount = searchForStopListParams.maxCount - additionalQueryParams(searchForStopListParams.additionalQueryParams) additionalHeaders(searchForStopListParams.additionalHeaders) + additionalQueryParams(searchForStopListParams.additionalQueryParams) } /** The string to search for. */ @@ -76,52 +78,92 @@ constructor( /** The max number of results to return. Defaults to 20. */ fun maxCount(maxCount: Long) = apply { this.maxCount = maxCount } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): SearchForStopListParams = SearchForStopListParams( checkNotNull(input) { "`input` is required but was not set" }, maxCount, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ShapeRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ShapeRetrieveParams.kt index a9e734c..b8227c8 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ShapeRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/ShapeRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class ShapeRetrieveParams constructor( private val shapeId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun shapeId(): String = shapeId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> shapeId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is ShapeRetrieveParams && this.shapeId == other.shapeId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is ShapeRetrieveParams && this.shapeId == other.shapeId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(shapeId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(shapeId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "ShapeRetrieveParams{shapeId=$shapeId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "ShapeRetrieveParams{shapeId=$shapeId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var shapeId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(shapeRetrieveParams: ShapeRetrieveParams) = apply { this.shapeId = shapeRetrieveParams.shapeId - additionalQueryParams(shapeRetrieveParams.additionalQueryParams) additionalHeaders(shapeRetrieveParams.additionalHeaders) + additionalQueryParams(shapeRetrieveParams.additionalQueryParams) } fun shapeId(shapeId: String) = apply { this.shapeId = shapeId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): ShapeRetrieveParams = ShapeRetrieveParams( checkNotNull(shapeId) { "`shapeId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopIdsForAgencyListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopIdsForAgencyListParams.kt index da3d43e..de4dde4 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopIdsForAgencyListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopIdsForAgencyListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class StopIdsForAgencyListParams constructor( private val agencyId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun agencyId(): String = agencyId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> agencyId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is StopIdsForAgencyListParams && this.agencyId == other.agencyId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is StopIdsForAgencyListParams && this.agencyId == other.agencyId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(agencyId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(agencyId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "StopIdsForAgencyListParams{agencyId=$agencyId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "StopIdsForAgencyListParams{agencyId=$agencyId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var agencyId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(stopIdsForAgencyListParams: StopIdsForAgencyListParams) = apply { this.agencyId = stopIdsForAgencyListParams.agencyId - additionalQueryParams(stopIdsForAgencyListParams.additionalQueryParams) additionalHeaders(stopIdsForAgencyListParams.additionalHeaders) + additionalQueryParams(stopIdsForAgencyListParams.additionalQueryParams) } fun agencyId(agencyId: String) = apply { this.agencyId = agencyId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): StopIdsForAgencyListParams = StopIdsForAgencyListParams( checkNotNull(agencyId) { "`agencyId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopRetrieveParams.kt index 5c49505..6715561 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class StopRetrieveParams constructor( private val stopId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun stopId(): String = stopId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> stopId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is StopRetrieveParams && this.stopId == other.stopId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is StopRetrieveParams && this.stopId == other.stopId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(stopId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(stopId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "StopRetrieveParams{stopId=$stopId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "StopRetrieveParams{stopId=$stopId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var stopId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(stopRetrieveParams: StopRetrieveParams) = apply { this.stopId = stopRetrieveParams.stopId - additionalQueryParams(stopRetrieveParams.additionalQueryParams) additionalHeaders(stopRetrieveParams.additionalHeaders) + additionalQueryParams(stopRetrieveParams.additionalQueryParams) } fun stopId(stopId: String) = apply { this.stopId = stopId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): StopRetrieveParams = StopRetrieveParams( checkNotNull(stopId) { "`stopId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForLocationListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForLocationListParams.kt index 2421b7c..2a45ced 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForLocationListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForLocationListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -15,8 +17,8 @@ constructor( private val lonSpan: Double?, private val query: String?, private val radius: Double?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun lat(): Double = lat @@ -31,6 +33,8 @@ constructor( fun radius(): Double? = radius + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.lat.let { params.put("lat", listOf(it.toString())) } @@ -43,26 +47,24 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Map> = additionalHeaders fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders - override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is StopsForLocationListParams && this.lat == other.lat && this.lon == other.lon && this.latSpan == other.latSpan && this.lonSpan == other.lonSpan && this.query == other.query && this.radius == other.radius && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is StopsForLocationListParams && this.lat == other.lat && this.lon == other.lon && this.latSpan == other.latSpan && this.lonSpan == other.lonSpan && this.query == other.query && this.radius == other.radius && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(lat, lon, latSpan, lonSpan, query, radius, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(lat, lon, latSpan, lonSpan, query, radius, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "StopsForLocationListParams{lat=$lat, lon=$lon, latSpan=$latSpan, lonSpan=$lonSpan, query=$query, radius=$radius, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "StopsForLocationListParams{lat=$lat, lon=$lon, latSpan=$latSpan, lonSpan=$lonSpan, query=$query, radius=$radius, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -80,8 +82,8 @@ constructor( private var lonSpan: Double? = null private var query: String? = null private var radius: Double? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(stopsForLocationListParams: StopsForLocationListParams) = apply { this.lat = stopsForLocationListParams.lat @@ -90,8 +92,8 @@ constructor( this.lonSpan = stopsForLocationListParams.lonSpan this.query = stopsForLocationListParams.query this.radius = stopsForLocationListParams.radius - additionalQueryParams(stopsForLocationListParams.additionalQueryParams) additionalHeaders(stopsForLocationListParams.additionalHeaders) + additionalQueryParams(stopsForLocationListParams.additionalQueryParams) } fun lat(lat: Double) = apply { this.lat = lat } @@ -110,45 +112,79 @@ constructor( /** The radius in meters to search within */ fun radius(radius: Double) = apply { this.radius = radius } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): StopsForLocationListParams = StopsForLocationListParams( @@ -158,8 +194,14 @@ constructor( lonSpan, query, radius, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForRouteListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForRouteListParams.kt index 2d5571b..88c7d11 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForRouteListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/StopsForRouteListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -12,8 +14,8 @@ constructor( private val routeId: String, private val includePolylines: Boolean?, private val time: String?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun routeId(): String = routeId @@ -22,6 +24,8 @@ constructor( fun time(): String? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.includePolylines?.let { params.put("includePolylines", listOf(it.toString())) } @@ -30,8 +34,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> routeId @@ -39,24 +41,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is StopsForRouteListParams && this.routeId == other.routeId && this.includePolylines == other.includePolylines && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is StopsForRouteListParams && this.routeId == other.routeId && this.includePolylines == other.includePolylines && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(routeId, includePolylines, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(routeId, includePolylines, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "StopsForRouteListParams{routeId=$routeId, includePolylines=$includePolylines, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "StopsForRouteListParams{routeId=$routeId, includePolylines=$includePolylines, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -71,15 +73,15 @@ constructor( private var routeId: String? = null private var includePolylines: Boolean? = null private var time: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(stopsForRouteListParams: StopsForRouteListParams) = apply { this.routeId = stopsForRouteListParams.routeId this.includePolylines = stopsForRouteListParams.includePolylines this.time = stopsForRouteListParams.time - additionalQueryParams(stopsForRouteListParams.additionalQueryParams) additionalHeaders(stopsForRouteListParams.additionalHeaders) + additionalQueryParams(stopsForRouteListParams.additionalQueryParams) } fun routeId(routeId: String) = apply { this.routeId = routeId } @@ -92,53 +94,93 @@ constructor( /** Specify service date (YYYY-MM-DD or epoch) (default today) */ fun time(time: String) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): StopsForRouteListParams = StopsForRouteListParams( checkNotNull(routeId) { "`routeId` is required but was not set" }, includePolylines, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripDetailRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripDetailRetrieveParams.kt index a648550..758b997 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripDetailRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripDetailRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -15,8 +17,8 @@ constructor( private val includeTrip: Boolean?, private val serviceDate: Long?, private val time: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun tripId(): String = tripId @@ -31,6 +33,8 @@ constructor( fun time(): Long? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.includeSchedule?.let { params.put("includeSchedule", listOf(it.toString())) } @@ -42,8 +46,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> tripId @@ -51,24 +53,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is TripDetailRetrieveParams && this.tripId == other.tripId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.includeTrip == other.includeTrip && this.serviceDate == other.serviceDate && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is TripDetailRetrieveParams && this.tripId == other.tripId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.includeTrip == other.includeTrip && this.serviceDate == other.serviceDate && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(tripId, includeSchedule, includeStatus, includeTrip, serviceDate, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(tripId, includeSchedule, includeStatus, includeTrip, serviceDate, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "TripDetailRetrieveParams{tripId=$tripId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, includeTrip=$includeTrip, serviceDate=$serviceDate, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "TripDetailRetrieveParams{tripId=$tripId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, includeTrip=$includeTrip, serviceDate=$serviceDate, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -86,8 +88,8 @@ constructor( private var includeTrip: Boolean? = null private var serviceDate: Long? = null private var time: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(tripDetailRetrieveParams: TripDetailRetrieveParams) = apply { this.tripId = tripDetailRetrieveParams.tripId @@ -96,8 +98,8 @@ constructor( this.includeTrip = tripDetailRetrieveParams.includeTrip this.serviceDate = tripDetailRetrieveParams.serviceDate this.time = tripDetailRetrieveParams.time - additionalQueryParams(tripDetailRetrieveParams.additionalQueryParams) additionalHeaders(tripDetailRetrieveParams.additionalHeaders) + additionalQueryParams(tripDetailRetrieveParams.additionalQueryParams) } fun tripId(tripId: String) = apply { this.tripId = tripId } @@ -126,45 +128,79 @@ constructor( /** Time parameter to query the system at a specific time (optional). */ fun time(time: Long) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): TripDetailRetrieveParams = TripDetailRetrieveParams( @@ -174,8 +210,14 @@ constructor( includeTrip, serviceDate, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripForVehicleRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripForVehicleRetrieveParams.kt index 7cbfc87..893e3bd 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripForVehicleRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripForVehicleRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -14,8 +16,8 @@ constructor( private val includeStatus: Boolean?, private val includeTrip: Boolean?, private val time: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun vehicleId(): String = vehicleId @@ -28,6 +30,8 @@ constructor( fun time(): Long? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.includeSchedule?.let { params.put("includeSchedule", listOf(it.toString())) } @@ -38,8 +42,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> vehicleId @@ -47,24 +49,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is TripForVehicleRetrieveParams && this.vehicleId == other.vehicleId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.includeTrip == other.includeTrip && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is TripForVehicleRetrieveParams && this.vehicleId == other.vehicleId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.includeTrip == other.includeTrip && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(vehicleId, includeSchedule, includeStatus, includeTrip, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(vehicleId, includeSchedule, includeStatus, includeTrip, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "TripForVehicleRetrieveParams{vehicleId=$vehicleId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, includeTrip=$includeTrip, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "TripForVehicleRetrieveParams{vehicleId=$vehicleId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, includeTrip=$includeTrip, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -81,8 +83,8 @@ constructor( private var includeStatus: Boolean? = null private var includeTrip: Boolean? = null private var time: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(tripForVehicleRetrieveParams: TripForVehicleRetrieveParams) = apply { this.vehicleId = tripForVehicleRetrieveParams.vehicleId @@ -90,8 +92,8 @@ constructor( this.includeStatus = tripForVehicleRetrieveParams.includeStatus this.includeTrip = tripForVehicleRetrieveParams.includeTrip this.time = tripForVehicleRetrieveParams.time - additionalQueryParams(tripForVehicleRetrieveParams.additionalQueryParams) additionalHeaders(tripForVehicleRetrieveParams.additionalHeaders) + additionalQueryParams(tripForVehicleRetrieveParams.additionalQueryParams) } fun vehicleId(vehicleId: String) = apply { this.vehicleId = vehicleId } @@ -119,45 +121,79 @@ constructor( /** Time parameter to query the system at a specific time (optional). */ fun time(time: Long) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): TripForVehicleRetrieveParams = TripForVehicleRetrieveParams( @@ -166,8 +202,14 @@ constructor( includeStatus, includeTrip, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripRetrieveParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripRetrieveParams.kt index 1e69cf3..9ef5afa 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripRetrieveParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripRetrieveParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -10,16 +12,16 @@ import org.onebusaway.models.* class TripRetrieveParams constructor( private val tripId: String, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun tripId(): String = tripId - internal fun getQueryParams(): Map> = additionalQueryParams - internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> = additionalQueryParams + fun getPathParam(index: Int): String { return when (index) { 0 -> tripId @@ -27,24 +29,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is TripRetrieveParams && this.tripId == other.tripId && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is TripRetrieveParams && this.tripId == other.tripId && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(tripId, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(tripId, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "TripRetrieveParams{tripId=$tripId, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "TripRetrieveParams{tripId=$tripId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -57,62 +59,102 @@ constructor( class Builder { private var tripId: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(tripRetrieveParams: TripRetrieveParams) = apply { this.tripId = tripRetrieveParams.tripId - additionalQueryParams(tripRetrieveParams.additionalQueryParams) additionalHeaders(tripRetrieveParams.additionalHeaders) + additionalQueryParams(tripRetrieveParams.additionalQueryParams) } fun tripId(tripId: String) = apply { this.tripId = tripId } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): TripRetrieveParams = TripRetrieveParams( checkNotNull(tripId) { "`tripId` is required but was not set" }, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForLocationListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForLocationListParams.kt index 0f75cb7..21b7bf3 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForLocationListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForLocationListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -16,8 +18,8 @@ constructor( private val includeSchedule: Boolean?, private val includeTrip: Boolean?, private val time: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun lat(): Double = lat @@ -34,6 +36,8 @@ constructor( fun time(): Long? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.lat.let { params.put("lat", listOf(it.toString())) } @@ -47,26 +51,24 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders + fun _additionalHeaders(): Map> = additionalHeaders fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders - override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is TripsForLocationListParams && this.lat == other.lat && this.latSpan == other.latSpan && this.lon == other.lon && this.lonSpan == other.lonSpan && this.includeSchedule == other.includeSchedule && this.includeTrip == other.includeTrip && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is TripsForLocationListParams && this.lat == other.lat && this.latSpan == other.latSpan && this.lon == other.lon && this.lonSpan == other.lonSpan && this.includeSchedule == other.includeSchedule && this.includeTrip == other.includeTrip && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(lat, latSpan, lon, lonSpan, includeSchedule, includeTrip, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(lat, latSpan, lon, lonSpan, includeSchedule, includeTrip, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "TripsForLocationListParams{lat=$lat, latSpan=$latSpan, lon=$lon, lonSpan=$lonSpan, includeSchedule=$includeSchedule, includeTrip=$includeTrip, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "TripsForLocationListParams{lat=$lat, latSpan=$latSpan, lon=$lon, lonSpan=$lonSpan, includeSchedule=$includeSchedule, includeTrip=$includeTrip, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -85,8 +87,8 @@ constructor( private var includeSchedule: Boolean? = null private var includeTrip: Boolean? = null private var time: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(tripsForLocationListParams: TripsForLocationListParams) = apply { this.lat = tripsForLocationListParams.lat @@ -96,8 +98,8 @@ constructor( this.includeSchedule = tripsForLocationListParams.includeSchedule this.includeTrip = tripsForLocationListParams.includeTrip this.time = tripsForLocationListParams.time - additionalQueryParams(tripsForLocationListParams.additionalQueryParams) additionalHeaders(tripsForLocationListParams.additionalHeaders) + additionalQueryParams(tripsForLocationListParams.additionalQueryParams) } /** The latitude coordinate of the search center */ @@ -125,45 +127,79 @@ constructor( /** Specific time for the query. Defaults to the current time. */ fun time(time: Long) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) + } + + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) + } + + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) + } + + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) + } + + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): TripsForLocationListParams = TripsForLocationListParams( @@ -174,8 +210,14 @@ constructor( includeSchedule, includeTrip, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForRouteListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForRouteListParams.kt index cdeae55..1721cca 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForRouteListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/TripsForRouteListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -13,8 +15,8 @@ constructor( private val includeSchedule: Boolean?, private val includeStatus: Boolean?, private val time: Long?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun routeId(): String = routeId @@ -25,6 +27,8 @@ constructor( fun time(): Long? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.includeSchedule?.let { params.put("includeSchedule", listOf(it.toString())) } @@ -34,8 +38,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> routeId @@ -43,24 +45,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is TripsForRouteListParams && this.routeId == other.routeId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is TripsForRouteListParams && this.routeId == other.routeId && this.includeSchedule == other.includeSchedule && this.includeStatus == other.includeStatus && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(routeId, includeSchedule, includeStatus, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(routeId, includeSchedule, includeStatus, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "TripsForRouteListParams{routeId=$routeId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "TripsForRouteListParams{routeId=$routeId, includeSchedule=$includeSchedule, includeStatus=$includeStatus, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -76,16 +78,16 @@ constructor( private var includeSchedule: Boolean? = null private var includeStatus: Boolean? = null private var time: Long? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(tripsForRouteListParams: TripsForRouteListParams) = apply { this.routeId = tripsForRouteListParams.routeId this.includeSchedule = tripsForRouteListParams.includeSchedule this.includeStatus = tripsForRouteListParams.includeStatus this.time = tripsForRouteListParams.time - additionalQueryParams(tripsForRouteListParams.additionalQueryParams) additionalHeaders(tripsForRouteListParams.additionalHeaders) + additionalQueryParams(tripsForRouteListParams.additionalQueryParams) } fun routeId(routeId: String) = apply { this.routeId = routeId } @@ -104,45 +106,79 @@ constructor( /** Query the system at a specific time. Useful for testing. */ fun time(time: Long) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): TripsForRouteListParams = TripsForRouteListParams( @@ -150,8 +186,14 @@ constructor( includeSchedule, includeStatus, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } } diff --git a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/VehiclesForAgencyListParams.kt b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/VehiclesForAgencyListParams.kt index 645a9a1..ced1edf 100644 --- a/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/VehiclesForAgencyListParams.kt +++ b/onebusaway-sdk-kotlin-core/src/main/kotlin/org/onebusaway/models/VehiclesForAgencyListParams.kt @@ -2,6 +2,8 @@ package org.onebusaway.models +import com.google.common.collect.ArrayListMultimap +import com.google.common.collect.ListMultimap import java.util.Objects import org.onebusaway.core.NoAutoDetect import org.onebusaway.core.toImmutable @@ -11,14 +13,16 @@ class VehiclesForAgencyListParams constructor( private val agencyId: String, private val time: String?, - private val additionalQueryParams: Map>, private val additionalHeaders: Map>, + private val additionalQueryParams: Map>, ) { fun agencyId(): String = agencyId fun time(): String? = time + internal fun getHeaders(): Map> = additionalHeaders + internal fun getQueryParams(): Map> { val params = mutableMapOf>() this.time?.let { params.put("time", listOf(it.toString())) } @@ -26,8 +30,6 @@ constructor( return params.toImmutable() } - internal fun getHeaders(): Map> = additionalHeaders - fun getPathParam(index: Int): String { return when (index) { 0 -> agencyId @@ -35,24 +37,24 @@ constructor( } } - fun _additionalQueryParams(): Map> = additionalQueryParams - fun _additionalHeaders(): Map> = additionalHeaders + fun _additionalQueryParams(): Map> = additionalQueryParams + override fun equals(other: Any?): Boolean { if (this === other) { return true } - return /* spotless:off */ other is VehiclesForAgencyListParams && this.agencyId == other.agencyId && this.time == other.time && this.additionalQueryParams == other.additionalQueryParams && this.additionalHeaders == other.additionalHeaders /* spotless:on */ + return /* spotless:off */ other is VehiclesForAgencyListParams && this.agencyId == other.agencyId && this.time == other.time && this.additionalHeaders == other.additionalHeaders && this.additionalQueryParams == other.additionalQueryParams /* spotless:on */ } override fun hashCode(): Int { - return /* spotless:off */ Objects.hash(agencyId, time, additionalQueryParams, additionalHeaders) /* spotless:on */ + return /* spotless:off */ Objects.hash(agencyId, time, additionalHeaders, additionalQueryParams) /* spotless:on */ } override fun toString() = - "VehiclesForAgencyListParams{agencyId=$agencyId, time=$time, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + "VehiclesForAgencyListParams{agencyId=$agencyId, time=$time, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}" fun toBuilder() = Builder().from(this) @@ -66,14 +68,14 @@ constructor( private var agencyId: String? = null private var time: String? = null - private var additionalQueryParams: MutableMap> = mutableMapOf() - private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalHeaders: ListMultimap = ArrayListMultimap.create() + private var additionalQueryParams: ListMultimap = ArrayListMultimap.create() internal fun from(vehiclesForAgencyListParams: VehiclesForAgencyListParams) = apply { this.agencyId = vehiclesForAgencyListParams.agencyId this.time = vehiclesForAgencyListParams.time - additionalQueryParams(vehiclesForAgencyListParams.additionalQueryParams) additionalHeaders(vehiclesForAgencyListParams.additionalHeaders) + additionalQueryParams(vehiclesForAgencyListParams.additionalQueryParams) } fun agencyId(agencyId: String) = apply { this.agencyId = agencyId } @@ -81,52 +83,92 @@ constructor( /** Specific time for querying the status (timestamp format) */ fun time(time: String) = apply { this.time = time } - fun additionalQueryParams(additionalQueryParams: Map>) = apply { - this.additionalQueryParams.clear() - putAllQueryParams(additionalQueryParams) + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllAdditionalHeaders(additionalHeaders) } - fun putQueryParam(name: String, value: String) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + fun putAdditionalHeader(name: String, value: String) = apply { + additionalHeaders.put(name, value) } - fun putQueryParams(name: String, values: Iterable) = apply { - this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + fun putAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.putAll(name, values) } - fun putAllQueryParams(additionalQueryParams: Map>) = apply { - additionalQueryParams.forEach(this::putQueryParams) + fun putAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::putAdditionalHeaders) } - fun removeQueryParam(name: String) = apply { - this.additionalQueryParams.put(name, mutableListOf()) + fun replaceAdditionalHeaders(name: String, value: String) = apply { + additionalHeaders.replaceValues(name, listOf(value)) } - fun additionalHeaders(additionalHeaders: Map>) = apply { - this.additionalHeaders.clear() - putAllHeaders(additionalHeaders) + fun replaceAdditionalHeaders(name: String, values: Iterable) = apply { + additionalHeaders.replaceValues(name, values) + } + + fun replaceAllAdditionalHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(::replaceAdditionalHeaders) + } + + fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.removeAll(name) } + + fun removeAllAdditionalHeaders(names: Set) = apply { + names.forEach(::removeAdditionalHeaders) + } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllAdditionalQueryParams(additionalQueryParams) + } + + fun putAdditionalQueryParam(key: String, value: String) = apply { + additionalQueryParams.put(key, value) + } + + fun putAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.putAll(key, values) } - fun putHeader(name: String, value: String) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + fun putAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::putAdditionalQueryParams) + } + + fun replaceAdditionalQueryParams(key: String, value: String) = apply { + additionalQueryParams.replaceValues(key, listOf(value)) } - fun putHeaders(name: String, values: Iterable) = apply { - this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + fun replaceAdditionalQueryParams(key: String, values: Iterable) = apply { + additionalQueryParams.replaceValues(key, values) } - fun putAllHeaders(additionalHeaders: Map>) = apply { - additionalHeaders.forEach(this::putHeaders) + fun replaceAllAdditionalQueryParams(additionalQueryParams: Map>) = + apply { + additionalQueryParams.forEach(::replaceAdditionalQueryParams) + } + + fun removeAdditionalQueryParams(key: String) = apply { + additionalQueryParams.removeAll(key) } - fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + fun removeAllAdditionalQueryParams(keys: Set) = apply { + keys.forEach(::removeAdditionalQueryParams) + } fun build(): VehiclesForAgencyListParams = VehiclesForAgencyListParams( checkNotNull(agencyId) { "`agencyId` is required but was not set" }, time, - additionalQueryParams.mapValues { it.value.toImmutable() }.toImmutable(), - additionalHeaders.mapValues { it.value.toImmutable() }.toImmutable(), + additionalHeaders + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), + additionalQueryParams + .asMap() + .mapValues { it.value.toList().toImmutable() } + .toImmutable(), ) } }