TemplateGenerator

abstract val defaultNamespace: String

abstract val experimentFlags: Seq[String]

abstract def fileExtension: 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 templates: HandlebarLoader

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

val TypeTemplate: Dictionary

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

final def asInstanceOf[T0]: T0

val basePassthrough: Dictionary

def clone(): AnyRef

def constDict(namespace: Identifier, consts: Seq[ConstDefinition]): Dictionary

def enumDict(namespace: Identifier, enum: Enum): Dictionary

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fieldsToDict(fields: Seq[Field], blacklist: Seq[String]): Seq[Dictionary]

def finagleClient(service: Service, namespace: Identifier): Dictionary

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

def finagleService(service: Service, namespace: Identifier): Dictionary

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

def genWireConstType(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

def internalArgsStruct(f: Function): FunctionArgs

def internalArgsStructName(f: Function): SimpleID

def internalArgsStructNameForWire(f: Function): String

The name used in RPC request, this needs to be same as Apache compiler

def internalResultStruct(f: Function): FunctionResult

def internalResultStructName(f: Function): SimpleID

def internalResultStructNameForWire(f: Function): String

The name used in RPC request, this needs to be same as Apache compiler

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

def readWriteInfo[T <: FieldType](sid: SimpleID, t: FieldType): Dictionary

def serviceDict(service: Service, namespace: Identifier, includes: Seq[Include], options: Set[ServiceOption]): Dictionary

def structDict(struct: StructLike, namespace: Option[Identifier], includes: Seq[Include], serviceOptions: Set[ServiceOption]): Dictionary

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

def toDictionary(function: Function, generic: Option[String]): Dictionary

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