wire-runtime/com.squareup.wire.internal

Package-level declarations

Types

DoubleArrayList

class DoubleArrayList(initialCapacity: Int)

Offers a nice wrapper around DoubleArray, that handles resizing the underlying array as needed and provides a trimToSize() method to truncate the underlying array to the current number of elements.

DurationJsonFormatter

object DurationJsonFormatter : JsonFormatter<Duration>

Encode a duration as a JSON string like "1.200s". From the spec:

EnumJsonFormatter

class EnumJsonFormatter<E : WireEnum>(adapter: EnumAdapter<E>) : JsonFormatter<E>

Encodes enums using their declared names as defined in WireEnumConstant or their generated names if the declared name is empty. Decodes using either their declared names, their generated names, or their tags.

class FieldBinding<M : Message<M, B>, B : Message.Builder<M, B>> : FieldOrOneOfBinding<M, B>

Read, write, and describe a tag within a message. This class knows how to assign fields to a builder object, and how to extract values from a message object.

FieldOrOneOfBinding

abstract class FieldOrOneOfBinding<M, B>

class FloatArrayList(initialCapacity: Int)

Offers a nice wrapper around FloatArray, that handles resizing the underlying array as needed and provides a trimToSize() method to truncate the underlying array to the current number of elements.

InstantJsonFormatter

object InstantJsonFormatter : JsonFormatter<Instant>

Encode an instant as a JSON string like "1950-01-01T00:00:00Z". From the spec:

class IntArrayList(initialCapacity: Int)

Offers a nice wrapper around IntArray, that handles resizing the underlying array as needed and provides a trimToSize() method to truncate the underlying array to the current number of elements.

interface JsonFormatter<W : Any>

Transforms a scalar value to and from JSON.

JsonIntegration

abstract class JsonIntegration<F, A>

Integrates a JSON library like Moshi or Gson into proto. This rigid interface attempts to make it easy all JSON libraries to encode and decode JSON in the exact same way.

JvmDefaultWithCompatibility

expect annotation class JvmDefaultWithCompatibility

actual typealias JvmDefaultWithCompatibility = kotlin.jvm.JvmDefaultWithCompatibility

expect annotation class JvmField

actual annotation class JvmField

This annotation is an empty placeholder.

actual typealias JvmField = kotlin.jvm.JvmField

actual annotation class JvmField

This annotation is an empty placeholder.

expect annotation class JvmStatic

actual annotation class JvmStatic

This annotation is an empty placeholder.

actual typealias JvmStatic = kotlin.jvm.JvmStatic

actual annotation class JvmStatic

This annotation is an empty placeholder.

expect annotation class JvmSynthetic

actual annotation class JvmSynthetic

This annotation is an empty placeholder.

actual typealias JvmSynthetic = kotlin.jvm.JvmSynthetic

actual annotation class JvmSynthetic

This annotation is an empty placeholder.

class LongArrayList(initialCapacity: Int)

Offers a nice wrapper around LongArray, that handles resizing the underlying array as needed and provides a trimToSize() method to truncate the underlying array to the current number of elements.

interface MessageBinding<M : Any, B : Any>

A representation of a message and its builder class. Typically these are generated subtypes of com.squareup.wire.Message and com.squareup.wire.Message.Builder.

ObjectStreamException

expect abstract class ObjectStreamException : IOException

actual abstract class ObjectStreamException : IOException

actual typealias ObjectStreamException = java.io.ObjectStreamException

actual abstract class ObjectStreamException : IOException

ProtocolException

expect class ProtocolException(host: String) : IOException

actual class ProtocolException(host: String) : IOException

actual typealias ProtocolException = java.net.ProtocolException

actual class ProtocolException(host: String) : IOException

RuntimeMessageAdapter

class RuntimeMessageAdapter<M : Any, B : Any>(binding: MessageBinding<M, B>) : ProtoAdapter<M>

expect interface Serializable

actual interface Serializable

actual typealias Serializable = java.io.Serializable

actual interface Serializable

expect annotation class Throws(val exceptionClasses: KClass<out Throwable>)

actual typealias Throws = kotlin.jvm.Throws

Properties

val <E : WireEnum> Class<E>.identityOrNull: E?

The enum with constant 0. This is non-null for proto3 enum types.

Functions

boxedOneOfClassName

fun boxedOneOfClassName(oneOfName: String): String

boxedOneOfKeyFieldName

fun boxedOneOfKeyFieldName(oneOfName: String, fieldName: String): String

Maps oneOfName and fieldName to the companion object key representing a boxed oneof field.

boxedOneOfKeysFieldName

fun boxedOneOfKeysFieldName(oneOfName: String): String

Maps oneOfName to the companion object field of type Set containing the eligible keys.

expect fun camelCase(string: String, upperCamel: Boolean = false): String

Convert string, from snake case to camel case.

actual fun camelCase(string: String, upperCamel: Boolean): String

actual fun camelCase(string: String, upperCamel: Boolean): String

actual fun camelCase(string: String, upperCamel: Boolean): String

checkElementsNotNull

fun checkElementsNotNull(list: List<*>)

Throw NullPointerException if any of list's items is null.

fun checkElementsNotNull(map: Map<*, *>)

Throw NullPointerException if any ofmap's keys or values is null.

fun <T> copyOf(list: List<T>): MutableList<T>

fun <K, V> copyOf(map: Map<K, V>): MutableMap<K, V>

fun <T> ~~copyOf~~(name: String, list: List<T>?): MutableList<T>

fun <K, V> ~~copyOf~~(name: String, map: Map<K, V>?): MutableMap<K, V>

fun countNonNull(a: Any?, b: Any?): Int

Returns the number of non-null values in a, b.

fun countNonNull(a: Any?, b: Any?, c: Any?): Int

Returns the number of non-null values in a, b, c.

fun countNonNull(a: Any?, b: Any?, c: Any?, d: Any?, vararg rest: Any?): Int

Returns the number of non-null values in a, b, c, d, rest.

createRuntimeMessageAdapter

fun <M : Message<M, B>, B : Message.Builder<M, B>> createRuntimeMessageAdapter(messageType: Class<M>, writeIdentityValues: Boolean, classLoader: ClassLoader? = messageType.classLoader): RuntimeMessageAdapter<M, B>

fun <M : Message<M, B>, B : Message.Builder<M, B>> createRuntimeMessageAdapter(messageType: Class<M>, typeUrl: String?, syntax: Syntax, classLoader: ClassLoader? = messageType.classLoader, writeIdentityValues: Boolean = false): RuntimeMessageAdapter<M, B>

decodePrimitive_double

fun decodePrimitive_double(reader: ProtoReader): Double

decodePrimitive_fixed32

fun decodePrimitive_fixed32(reader: ProtoReader): Int

decodePrimitive_fixed64

fun decodePrimitive_fixed64(reader: ProtoReader): Long

decodePrimitive_float

fun decodePrimitive_float(reader: ProtoReader): Float

decodePrimitive_int32

fun decodePrimitive_int32(reader: ProtoReader): Int

decodePrimitive_int64

fun decodePrimitive_int64(reader: ProtoReader): Long

decodePrimitive_sfixed32

fun decodePrimitive_sfixed32(reader: ProtoReader): Int

decodePrimitive_sfixed64

fun decodePrimitive_sfixed64(reader: ProtoReader): Long

decodePrimitive_sint32

fun decodePrimitive_sint32(reader: ProtoReader): Int

decodePrimitive_sint64

fun decodePrimitive_sint64(reader: ProtoReader): Long

decodePrimitive_uint32

fun decodePrimitive_uint32(reader: ProtoReader): Int

decodePrimitive_uint64

fun decodePrimitive_uint64(reader: ProtoReader): Long

encodeArray_double

fun encodeArray_double(array: DoubleArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_fixed32

fun encodeArray_fixed32(array: IntArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_fixed64

fun encodeArray_fixed64(array: LongArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_float

fun encodeArray_float(array: FloatArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_int32

fun encodeArray_int32(array: IntArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_int64

fun encodeArray_int64(array: LongArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_sfixed32

fun encodeArray_sfixed32(array: IntArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_sfixed64

fun encodeArray_sfixed64(array: LongArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_sint32

fun encodeArray_sint32(array: IntArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_sint64

fun encodeArray_sint64(array: LongArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_uint32

fun encodeArray_uint32(array: IntArray, writer: ReverseProtoWriter, tag: Int)

encodeArray_uint64

fun encodeArray_uint64(array: LongArray, writer: ReverseProtoWriter, tag: Int)

fun equals(a: Any?, b: Any?): Boolean

immutableCopyOf

fun <T> immutableCopyOf(name: String, list: List<T>): List<T>

fun <K, V> immutableCopyOf(name: String, map: Map<K, V>): Map<K, V>

immutableCopyOfMapWithStructValues

fun <K, V> immutableCopyOfMapWithStructValues(name: String, map: Map<K, V>): Map<K, V>

Confirms the values of map are structs and returns an immutable copy.

immutableCopyOfStruct

fun <T> immutableCopyOfStruct(name: String, value: T): T

Confirms value is a struct and returns an immutable copy.

missingRequiredFields

fun missingRequiredFields(vararg args: Any?): IllegalStateException

Create an exception for missing required fields.

fun <T> newMutableList(): MutableList<T>

fun <K, V> newMutableMap(): MutableMap<K, V>

fun <T> redactElements(list: MutableList<T>, adapter: ProtoAdapter<T>)

fun <T> redactElements(map: MutableMap<*, T>, adapter: ProtoAdapter<T>)

@JvmName(name = "-redactElements")

fun <T> List<T>.redactElements(adapter: ProtoAdapter<T>): List<T>

@JvmName(name = "-redactElements")

fun <K, V> Map<K, V>.redactElements(adapter: ProtoAdapter<V>): Map<K, V>

fun sanitize(value: String): String

fun sanitize(values: List<String>): String

Return a string where ,[]{}\ are escaped with a \.

toUnmodifiableList

expect fun <T> MutableList<T>.toUnmodifiableList(): List<T>

actual inline fun <T> MutableList<T>.toUnmodifiableList(): List<T>

actual inline fun <T> MutableList<T>.toUnmodifiableList(): List<T>

actual inline fun <T> MutableList<T>.toUnmodifiableList(): List<T>

toUnmodifiableMap

expect fun <K, V> MutableMap<K, V>.toUnmodifiableMap(): Map<K, V>

actual inline fun <K, V> MutableMap<K, V>.toUnmodifiableMap(): Map<K, V>

actual inline fun <K, V> MutableMap<K, V>.toUnmodifiableMap(): Map<K, V>

actual inline fun <K, V> MutableMap<K, V>.toUnmodifiableMap(): Map<K, V>