MutableProgramProxy

abstract def underlying: MutableProgram

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def <(that: Program): Boolean

def <=(that: Program): Boolean

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def >(that: Program): Boolean

def >=(that: Program): Boolean

final def asInstanceOf[T0]: T0

def clear(): Unit

def clone(): AnyRef

def compare(that: Program): Int

def compareTo(that: Program): Int

def constants: Seq[Const]

def constantsIsSet: Boolean

def constantsOption: Option[Seq[Const]]

def constantsOrDefault: Seq[Const]

def constantsOrNull: Seq[Const]

def constantsOrThrow: Seq[Const]

def constantsUnset(): Unit

def constants_=(x: Seq[Const]): Unit

def copy(namespaces: Seq[Namespace] = namespacesOrNull, includes: Seq[Include] = includesOrNull, constants: Seq[Const] = constantsOrNull, enums: Seq[Enum] = enumsOrNull, typedefs: Seq[Typedef] = typedefsOrNull, structs: Seq[Struct] = structsOrNull, unions: Seq[Union] = unionsOrNull, exceptions: Seq[Exception] = exceptionsOrNull, services: Seq[Service] = servicesOrNull, typeRegistry: TypeRegistry = typeRegistryOrNull): Mutable

def deepCopy(): Program

def enums: Seq[Enum]

def enumsIsSet: Boolean

def enumsOption: Option[Seq[Enum]]

def enumsOrDefault: Seq[Enum]

def enumsOrNull: Seq[Enum]

def enumsOrThrow: Seq[Enum]

def enumsUnset(): Unit

def enums_=(x: Seq[Enum]): Unit

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def exceptions: Seq[Exception]

def exceptionsIsSet: Boolean

def exceptionsOption: Option[Seq[Exception]]

def exceptionsOrDefault: Seq[Exception]

def exceptionsOrNull: Seq[Exception]

def exceptionsOrThrow: Seq[Exception]

def exceptionsUnset(): Unit

def exceptions_=(x: Seq[Exception]): Unit

def fieldForId(id: Int): _Fields

def finalize(): Unit

final def getClass(): Class[_]

def getFieldValue(field: _Fields): AnyRef

def hashCode(): Int

def includes: Seq[Include]

def includesIsSet: Boolean

def includesOption: Option[Seq[Include]]

def includesOrDefault: Seq[Include]

def includesOrNull: Seq[Include]

def includesOrThrow: Seq[Include]

def includesUnset(): Unit

def includes_=(x: Seq[Include]): Unit

final def isInstanceOf[T0]: Boolean

def isSet(field: _Fields): Boolean

def merge(that: Program): Unit

def mergeCopy(that: Program): Program

def meta: Program.type

def mutable: Mutable

Returns a pointer to a Mutable version of this record.

def mutableCopy(): Mutable

def namespaces: Seq[Namespace]

def namespacesIsSet: Boolean

def namespacesOption: Option[Seq[Namespace]]

def namespacesOrDefault: Seq[Namespace]

def namespacesOrNull: Seq[Namespace]

def namespacesOrThrow: Seq[Namespace]

def namespacesUnset(): Unit

def namespaces_=(x: Seq[Namespace]): Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def read(iprot: TProtocol): Unit

def services: Seq[Service]

def servicesIsSet: Boolean

def servicesOption: Option[Seq[Service]]

def servicesOrDefault: Seq[Service]

def servicesOrNull: Seq[Service]

def servicesOrThrow: Seq[Service]

def servicesUnset(): Unit

def services_=(x: Seq[Service]): Unit

def setFieldValue(field: _Fields, value: AnyRef): Unit

def structs: Seq[Struct]

def structsIsSet: Boolean

def structsOption: Option[Seq[Struct]]

def structsOrDefault: Seq[Struct]

def structsOrNull: Seq[Struct]

def structsOrThrow: Seq[Struct]

def structsUnset(): Unit

def structs_=(x: Seq[Struct]): Unit

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

def toBuilder(): AllSpecified

def toString(): String

def typeRegistry: TypeRegistry

def typeRegistryIsSet: Boolean

def typeRegistryOption: Option[TypeRegistry]

def typeRegistryOrNull: TypeRegistry

def typeRegistryOrThrow: TypeRegistry

def typeRegistryUnset(): Unit

def typeRegistry_=(x: TypeRegistry): Unit

def typedefs: Seq[Typedef]

def typedefsIsSet: Boolean

def typedefsOption: Option[Seq[Typedef]]

def typedefsOrDefault: Seq[Typedef]

def typedefsOrNull: Seq[Typedef]

def typedefsOrThrow: Seq[Typedef]

def typedefsUnset(): Unit

def typedefs_=(x: Seq[Typedef]): Unit

def unions: Seq[Union]

def unionsIsSet: Boolean

def unionsOption: Option[Seq[Union]]

def unionsOrDefault: Seq[Union]

def unionsOrNull: Seq[Union]

def unionsOrThrow: Seq[Union]

def unionsUnset(): Unit

def unions_=(x: Seq[Union]): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write(oprot: TProtocol): Unit