Generator

abstract def apply(_doc: Document, serviceOptions: Set[ServiceOption], outputPath: File, dryRun: Boolean = false): Iterable[File]

abstract val defaultNamespace: String

abstract val experimentFlags: Seq[String]

abstract def genBaseFinagleService: CodeFragment

abstract def genEnum(enum: EnumRHS, fieldType: Option[FieldType] = None): CodeFragment

abstract def genFieldParams(fields: Seq[Field], asVal: Boolean = false): CodeFragment

abstract def genFieldType(f: Field, mutable: Boolean = false): CodeFragment

abstract def genList(list: ListRHS, mutable: Boolean = false): CodeFragment

abstract def genMap(map: MapRHS, mutable: Boolean = false): CodeFragment

abstract def genPrimitiveType(t: FunctionType, mutable: Boolean = false): CodeFragment

abstract def genSet(set: SetRHS, mutable: Boolean = false, fieldType: Option[FieldType] = None): CodeFragment

abstract def genStruct(struct: StructRHS): CodeFragment

abstract def genToImmutable(f: Field): CodeFragment

Generates a suffix to append to a field expression that will convert the value to an immutable equivalent.

abstract def genToImmutable(t: FieldType): CodeFragment

Generates a suffix to append to a field expression that will convert the value to an immutable equivalent.

abstract def genType(t: FunctionType, mutable: Boolean = false): CodeFragment

abstract def getParentFinagleClient(parent: ServiceParent): CodeFragment

abstract def getParentFinagleService(parent: ServiceParent): CodeFragment

abstract val includeMap: Map[String, ResolvedDocument]

Map from included file names to the namespaces defined in those files.

abstract def normalizeCase[N <: Node](node: N): N

abstract def quoteKeyword(str: String): String

abstract def toMutable(f: Field): (String, String)

Generates a prefix and suffix to wrap around a field expression that will convert the value to a mutable equivalent.

abstract def toMutable(t: FieldType): (String, String)

Generates a prefix and suffix to wrap around a field expression that will convert the value to a mutable equivalent.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finagleClientFile(packageDir: File, service: Service, options: Set[ServiceOption]): Option[File]

def finagleServiceFile(packageDir: File, service: Service, options: Set[ServiceOption]): Option[File]

def finalize(): Unit

def genConstType(t: FunctionType): CodeFragment

def genConstant(constant: RHS, mutable: Boolean = false, fieldType: Option[FieldType] = None): CodeFragment

def genDefaultFieldValue(f: Field): Option[CodeFragment]

def genDefaultReadValue(f: Field): CodeFragment

def genDefaultValue(fieldType: FieldType, mutable: Boolean = false): CodeFragment

The default value for the specified type and mutability.

def genID(data: Identifier): CodeFragment

def genProtocolReadMethod(t: FunctionType): CodeFragment

def genProtocolWriteMethod(t: FunctionType): CodeFragment

final def getClass(): Class[_]

def getIncludeNamespace(includeFileName: String): Identifier

def getNamespace(doc: Document): Identifier

def getServiceParentID(parent: ServiceParent): Identifier

get the ID of a service parent.

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isNullableType(t: FieldType, isOptional: Boolean = false): Boolean

def isPrimitive(t: FunctionType): Boolean

def namespacedFolder(destFolder: File, namespace: String, dryRun: Boolean): File

****************** helper functions ***********************

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def qualifyNamedType(t: NamedType): Identifier

When a named type is imported via include statement, we need to qualify it using its full namespace

def quote(str: String): String

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeFile(file: File, fileHeader: String, fileContent: String): Unit