vdltool

type Config struct {
	// GenLanguages restricts the set of code generation languages.  If the set is
	// empty, all supported languages are allowed to be generated.
	GenLanguages map[GenLanguage]struct{}
	// Language-specific configurations.
	Go         GoConfig
	Java       JavaConfig
	Javascript JavascriptConfig
	Swift      SwiftConfig
}

type ConfigTarget struct {
	Value *Config

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type GenLanguage int

type GenLanguageTarget struct {
	Value *GenLanguage
	vdl.TargetBase
}

type GoConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Go
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Go
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use the standard Go
	// time package.
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes the existence of a pair of conversion functions
	// converting between the wire and native types, and will automatically call
	// vdl.RegisterNative with these function names.
	//
	// Assuming the name of the WireType is Foo:
	//   func fooToNative(x Foo, n *Native) error
	//   func fooFromNative(x *Foo, n Native) error
	WireToNativeTypes map[string]GoType
}

type GoConfigTarget struct {
	Value *GoConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type GoImport struct {
	// Path is the package path that uniquely identifies the imported package.
	Path string
	// Name is the name of the package identified by Path.  Due to Go conventions,
	// it is typically just the basename of Path, but may be set to something
	// different if the imported package doesn't follow Go conventions.
	Name string
}

type GoImportTarget struct {
	Value *GoImport

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type GoKind int

type GoKindTarget struct {
	Value *GoKind
	vdl.TargetBase
}

type GoType struct {
	// Kind is the kind of Type.
	Kind GoKind
	// Type is the Go type to use in generated code, instead of the VDL type.
	//
	// If the Go type requires additional imports, specify the type using the
	// standard local package name here, and also specify the import package in
	// Imports.  E.g. to specify the native type time.Duration:
	//   Kind:    Number
	//   Type:    "time.Duration",
	//   Imports: {{Path: "time", Name: "time"}},
	//   Zero:    {Mode: Unique}
	Type string
	// Imports are the Go imports required by the Type, used in generated code.
	Imports []GoImport
	// Zero specifies special behavior for zero value setting and checking.
	Zero GoZero
}

type GoTypeTarget struct {
	Value *GoType

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type GoZero struct {
	Mode GoZeroMode
	// IsZero specifies a field, method or function that returns true iff the
	// native value represents the VDL zero value.
	//
	// If IsZero starts with a dot (.), it is assumed to be a field or method.
	// The field type or method return type must be bool.  Generated code will
	// apply the IsZero string verbatim to expressions of the native type.
	//
	// If IsZero doesn't start with a dot(.), it is assumed to be a function whose
	// return type must be bool.  Generated code will call the function with all
	// occurrences of XXX replaced with an expression of the native type.
	//
	// TODO(toddw): The function form of IsZero isn't implemented, and also needs
	// another field to handle imports:
	//    IsZeroImports []GoImport
	IsZero string
}

type GoZeroMode int

type GoZeroModeTarget struct {
	Value *GoZeroMode
	vdl.TargetBase
}

type GoZeroTarget struct {
	Value *GoZero

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type JavaConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Java
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Java
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use the org.joda.time
	// package.
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes that the conversion functions will be registered
	// in java vdl package.
	WireToNativeTypes map[string]string
	// WireTypeRenames specifies the mapping from a VDL wire type name to its
	// Java native type name.
	//
	// WireTypeRenames are meant for scenarios where the VDL wire name
	// conflicts in some way with the Java native names, e.g., a VDL Integer
	// type could be named VInteger for clarity.
	//
	// When combined with WireToNativeTypes, this feature allows us to attach
	// functions to VDL types.  For example, we may rename AccessList VDL type
	// into WireAccessList and then map WireAccessList to our Java native type
	// AccessList which defines functions on the VDL data.
	//
	// The key of the map is the name of the VDL wire type, which must be
	// defined in the vdl package associated with the vdl.config file.
	WireTypeRenames map[string]string
}

type JavaConfigTarget struct {
	Value *JavaConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}

type JavascriptConfig struct {
}

type JavascriptConfigTarget struct {
	Value *JavascriptConfig
	vdl.TargetBase
	vdl.FieldsTargetBase
}

type SwiftConfig struct {
	// WireToNativeTypes specifies the mapping from a VDL wire type to its Swift
	// native type representation.  This is rarely used and easy to configure
	// incorrectly; usage is currently restricted to packages that are explicitly
	// whitelisted.
	//
	// WireToNativeTypes are meant for scenarios where there is an idiomatic Swift
	// type used in your code, but you need a standard VDL representation for wire
	// compatibility.  E.g. the VDL time package defines Duration and Time for
	// wire compatibility, but we want the generated code to use NSDate or NSTimeInterval
	//
	// The key of the map is the name of the VDL type (aka WireType), which must
	// be defined in the vdl package associated with the vdl.config file.
	//
	// The code generator assumes that the conversion functions will be registered
	// in Swift vdl package.
	WireToNativeTypes map[string]string
}

type SwiftConfigTarget struct {
	Value *SwiftConfig

	vdl.TargetBase
	vdl.FieldsTargetBase
}