TemplateGenerator

abstract val defaultNamespace: String

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

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): CodeFragment

abstract def genList(list: ListRHS, fieldType: Option[FieldType] = None): CodeFragment

abstract def genMap(map: MapRHS, fieldType: Option[FieldType] = None): CodeFragment

abstract def genPrimitiveType(t: FunctionType): CodeFragment

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

abstract def genStruct(struct: StructRHS, fieldType: Option[FieldType] = None): CodeFragment

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

abstract def genUnion(union: UnionRHS, fieldType: Option[FieldType] = None): CodeFragment

abstract def getParentFinagleClient(parent: ServiceParent): CodeFragment

abstract def getParentFinagleService(parent: ServiceParent): CodeFragment

abstract val languageFlags: Seq[String]

abstract def namespaceLanguage: String

Used to find the namespace in included files.

abstract def quoteKeyword(str: String): String

abstract def templates: HandlebarLoader

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(serviceOptions: Set[ServiceOption], outputPath: File, dryRun: Boolean = false, genAdapt: 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], namespace: Option[Identifier] = None): Seq[Dictionary]

def finagleClient(service: Service, namespace: Identifier, withAsClosable: Boolean): 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 functionArgsStruct(f: Function): FunctionArgs

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

def functionObjectName(f: Function): SimpleID

def genConstType(t: FunctionType): CodeFragment

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

def genDecodeProtocolMethod(t: FunctionType): CodeFragment

def genDefaultFieldValue(f: Field, forAlternateConstructor: Boolean = false): Option[CodeFragment]

Creates a code fragment for the default value of the field.

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

def genDefaultReadValue(f: Field): CodeFragment

def genDefaultValue(fieldType: FieldType): CodeFragment

The default value for the specified type and mutability.

def genID(data: Identifier): CodeFragment

def genOffsetSkipProtocolMethod(t: FunctionType): CodeFragment

def genProtocolReadMethod(t: FunctionType): CodeFragment

def genProtocolSkipMethod(t: FunctionType): CodeFragment

def genProtocolWriteMethod(t: FunctionType): CodeFragment

def genQualifiedID(id: Identifier, namespace: Identifier): CodeFragment

def genUnsafeEmptyReadValue(f: Field): CodeFragment

def genUnsafeEmptyValue(fieldType: FieldType): CodeFragment

The default value for the unsafe empty value case.

def genWireConstType(t: FunctionType): CodeFragment

final def getClass(): Class[_]

def getExceptionFields(result: FunctionResult): CodeFragment

def getIncludeNamespace(includeFileName: String): Identifier

def getNamespace(doc: Document): Identifier

def getServiceParentID(parent: ServiceParent): Identifier

def getSuccessType(result: FunctionResult): CodeFragment

def getSuccessValue(result: FunctionResult): CodeFragment

def getValidator(doc: Document): Option[Identifier]

def hashCode(): Int

def includeMap: Map[String, ResolvedDocument]

def internalArgsStructNameForWire(f: Function): String

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

final def isInstanceOf[T0]: Boolean

def isLazyReadEnabled(t: FunctionType, optional: Boolean): Boolean

def isNullValid(f: Field): Boolean

def isNullableType(f: Field): Boolean

def isPrimitive(t: FunctionType): Boolean

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

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

final def ne(arg0: AnyRef): Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

def productN(fields: Seq[Field], namespace: Option[Identifier]): String

Returns a String "_root_.

def qualifyNamedType(t: NamedType, namespace: Option[Identifier] = None): 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

val resolvedDoc: ResolvedDocument

def resultStruct(f: Function): FunctionResult

Thrift Result struct that includes success or exceptions returned.

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

def structDict(struct: StructLike, namespace: Option[Identifier], includes: Seq[Include], serviceOptions: Set[ServiceOption], genAdapt: Boolean, toplevel: Boolean = false, validator: Option[Identifier] = None): Dictionary

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

def toString(): String

def tupleN(fields: Seq[Field], namespace: Option[Identifier]): String

Returns a String "_root_.

def unwrapArgs(arity: Int): String

def validateStructAnnotations(structs: Seq[StructLike]): Unit

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