vdltool

package
v0.1.20 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Sep 25, 2021 License: BSD-3-Clause Imports: 2 Imported by: 22

Documentation

Overview

Package vdltool defines types used by the vdl tool itself, including the format of vdl.config files. No packages other than the vdltool command line tool and v.io/x/ref/lib/vdl/... packages should use it.

Index

Constants

This section is empty.

Variables

GenLanguageAll holds all labels for GenLanguage.

GoKindAll holds all labels for GoKind.

GoZeroModeAll holds all labels for GoZeroMode.

Functions

This section is empty.

Types

type Config

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
}

Config specifies the configuration for the vdl tool. This is typically represented in optional "vdl.config" files in each vdl source package. Each vdl.config file implicitly imports this package. E.g. you may refer to vdltool.Config in the "vdl.config" file without explicitly importing vdltool.

func (Config) VDLIsZero

func (x Config) VDLIsZero() bool

func (*Config) VDLRead

func (x *Config) VDLRead(dec vdl.Decoder) error

func (Config) VDLReflect

func (Config) VDLReflect(struct {
	Name string `vdl:"vdltool.Config"`
})

func (Config) VDLWrite

func (x Config) VDLWrite(enc vdl.Encoder) error

type GenLanguage

type GenLanguage int

GenLanguage enumerates the known code generation languages.

const (
	GenLanguageGo GenLanguage = iota
	GenLanguageJava
	GenLanguageJavascript
	GenLanguageSwift
)

func GenLanguageFromString

func GenLanguageFromString(label string) (x GenLanguage, err error)

GenLanguageFromString creates a GenLanguage from a string label.

func (*GenLanguage) Set

func (x *GenLanguage) Set(label string) error

Set assigns label to x.

func (GenLanguage) String

func (x GenLanguage) String() string

String returns the string label of x.

func (GenLanguage) VDLIsZero

func (x GenLanguage) VDLIsZero() bool

func (*GenLanguage) VDLRead

func (x *GenLanguage) VDLRead(dec vdl.Decoder) error

func (GenLanguage) VDLReflect

func (GenLanguage) VDLReflect(struct {
	Name string `vdl:"vdltool.GenLanguage"`
	Enum struct{ Go, Java, Javascript, Swift string }
})

func (GenLanguage) VDLWrite

func (x GenLanguage) VDLWrite(enc vdl.Encoder) error

type GoConfig

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
	// StructTags specifies any go struct tags to be include with the generated
	// go code. The StructTags map is keyed by the struct type's name.
	StructTags map[string][]GoStructTag
}

GoConfig specifies go specific configuration.

func (GoConfig) VDLIsZero

func (x GoConfig) VDLIsZero() bool

func (*GoConfig) VDLRead

func (x *GoConfig) VDLRead(dec vdl.Decoder) error

func (GoConfig) VDLReflect

func (GoConfig) VDLReflect(struct {
	Name string `vdl:"vdltool.GoConfig"`
})

func (GoConfig) VDLWrite

func (x GoConfig) VDLWrite(enc vdl.Encoder) error

type GoImport

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
}

GoImport describes Go import information.

func (GoImport) VDLIsZero

func (x GoImport) VDLIsZero() bool

func (*GoImport) VDLRead

func (x *GoImport) VDLRead(dec vdl.Decoder) error

func (GoImport) VDLReflect

func (GoImport) VDLReflect(struct {
	Name string `vdl:"vdltool.GoImport"`
})

func (GoImport) VDLWrite

func (x GoImport) VDLWrite(enc vdl.Encoder) error

type GoKind

type GoKind int

GoKind describes the kind of Go type.

const (
	GoKindStruct GoKind = iota
	GoKindBool
	GoKindNumber
	GoKindString
	GoKindArray
	GoKindSlice
	GoKindMap
	GoKindPointer
	GoKindIface
)

func GoKindFromString

func GoKindFromString(label string) (x GoKind, err error)

GoKindFromString creates a GoKind from a string label.

func (*GoKind) Set

func (x *GoKind) Set(label string) error

Set assigns label to x.

func (GoKind) String

func (x GoKind) String() string

String returns the string label of x.

func (GoKind) VDLIsZero

func (x GoKind) VDLIsZero() bool

func (*GoKind) VDLRead

func (x *GoKind) VDLRead(dec vdl.Decoder) error

func (GoKind) VDLReflect

func (GoKind) VDLReflect(struct {
	Name string `vdl:"vdltool.GoKind"`
	Enum struct{ Struct, Bool, Number, String, Array, Slice, Map, Pointer, Iface string }
})

func (GoKind) VDLWrite

func (x GoKind) VDLWrite(enc vdl.Encoder) error

type GoStructTag added in v0.1.14

type GoStructTag struct {
	Field string
	Tag   string
}

GoStructTag specifies a single go struct tag and the field to which it should be applied.

func (GoStructTag) VDLIsZero added in v0.1.14

func (x GoStructTag) VDLIsZero() bool

func (*GoStructTag) VDLRead added in v0.1.14

func (x *GoStructTag) VDLRead(dec vdl.Decoder) error

func (GoStructTag) VDLReflect added in v0.1.14

func (GoStructTag) VDLReflect(struct {
	Name string `vdl:"vdltool.GoStructTag"`
})

func (GoStructTag) VDLWrite added in v0.1.14

func (x GoStructTag) VDLWrite(enc vdl.Encoder) error

type GoType

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.
	Type string
	// Zero specifies zero value setting and checking behavior.
	Zero GoZero
	// ToNative and FromNative overrides the names of the native conversion
	// functions.  If unspecified, the default functions are of the form:
	//   WireTypeToNative(wire WireType, native *NativeType) error
	//   WireTypeFromNative(wire *WireType, native NativeType) error
	ToNative   string
	FromNative string
	// Imports are the Go imports referenced by the Type, ToNative and FromNative
	// fields.  In each field, use the standard local package name, and specify
	// the import package here.  E.g. to specify the native type time.Time:
	//   GoType{
	//     Kind:    Struct,
	//     Type:    "time.Time",
	//     Zero:    {Mode: Canonical, IsZero: ".IsZero()"},
	//     Imports: {{Path: "time", Name: "time"}},
	//   }
	Imports []GoImport
}

GoType describes the Go type information associated with a VDL type. See v.io/x/ref/lib/vdl/testdata/native for examples.

func (GoType) VDLIsZero

func (x GoType) VDLIsZero() bool

func (*GoType) VDLRead

func (x *GoType) VDLRead(dec vdl.Decoder) error

func (GoType) VDLReflect

func (GoType) VDLReflect(struct {
	Name string `vdl:"vdltool.GoType"`
})

func (GoType) VDLWrite

func (x GoType) VDLWrite(enc vdl.Encoder) error

type GoZero

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 a
	// single argument that is an expression of the native type.
	//
	// TODO(toddw): The function form of IsZero isn't implemented.
	IsZero string
}

GoZero describes Go zero value behavior.

REQUIRED: Either Mode == Unique or IsZero is set. We will not perform native/wire conversions to check zero values.

func (GoZero) VDLIsZero

func (x GoZero) VDLIsZero() bool

func (*GoZero) VDLRead

func (x *GoZero) VDLRead(dec vdl.Decoder) error

func (GoZero) VDLReflect

func (GoZero) VDLReflect(struct {
	Name string `vdl:"vdltool.GoZero"`
})

func (GoZero) VDLWrite

func (x GoZero) VDLWrite(enc vdl.Encoder) error

type GoZeroMode

type GoZeroMode int

GoZeroMode describes the relationship between the Go zero value of the native type, and the VDL zero value.

const (
	GoZeroModeUnknown GoZeroMode = iota
	GoZeroModeCanonical
	GoZeroModeUnique
)

func GoZeroModeFromString

func GoZeroModeFromString(label string) (x GoZeroMode, err error)

GoZeroModeFromString creates a GoZeroMode from a string label.

func (*GoZeroMode) Set

func (x *GoZeroMode) Set(label string) error

Set assigns label to x.

func (GoZeroMode) String

func (x GoZeroMode) String() string

String returns the string label of x.

func (GoZeroMode) VDLIsZero

func (x GoZeroMode) VDLIsZero() bool

func (*GoZeroMode) VDLRead

func (x *GoZeroMode) VDLRead(dec vdl.Decoder) error

func (GoZeroMode) VDLReflect

func (GoZeroMode) VDLReflect(struct {
	Name string `vdl:"vdltool.GoZeroMode"`
	Enum struct{ Unknown, Canonical, Unique string }
})

func (GoZeroMode) VDLWrite

func (x GoZeroMode) VDLWrite(enc vdl.Encoder) error

type JavaConfig

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
}

JavaConfig specifies java specific configuration.

func (JavaConfig) VDLIsZero

func (x JavaConfig) VDLIsZero() bool

func (*JavaConfig) VDLRead

func (x *JavaConfig) VDLRead(dec vdl.Decoder) error

func (JavaConfig) VDLReflect

func (JavaConfig) VDLReflect(struct {
	Name string `vdl:"vdltool.JavaConfig"`
})

func (JavaConfig) VDLWrite

func (x JavaConfig) VDLWrite(enc vdl.Encoder) error

type JavascriptConfig

type JavascriptConfig struct {
}

JavascriptConfig specifies javascript specific configuration.

func (JavascriptConfig) VDLIsZero

func (x JavascriptConfig) VDLIsZero() bool

func (*JavascriptConfig) VDLRead

func (x *JavascriptConfig) VDLRead(dec vdl.Decoder) error

func (JavascriptConfig) VDLReflect

func (JavascriptConfig) VDLReflect(struct {
	Name string `vdl:"vdltool.JavascriptConfig"`
})

func (JavascriptConfig) VDLWrite

func (x JavascriptConfig) VDLWrite(enc vdl.Encoder) error

type SwiftConfig

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
}

SwiftConfig specifies swift specific configuration for this package. Note that despite the SwiftConfig options for a given package (which should be very rare in practice), we still need to know the name of the swift module that this package relates to to properly understand import boundaries between projects/frameworks/modules.

We do this by defining a file called "swiftmodule" that contains JUST the name of the Swift module at the root of your VDL packages. For example, if you have the VDL files for your Xcode project/target called UberForCats at /Users/aaron/uberforcats/vdl, then create /Users/aaron/uberforcats/vdl/com.uberforcats/swiftmodule and have it just contain "UberForCats". We then will treat any VDL files contained in that directory and any subdirectories as part of the UberForCats Swift module, ultimately letting the compiler and will automatically do the right thing if others import your package. If you don't do this then nobody will be able to import your VDL types in Swift, and you might end up with extra long class/pkg names (ComuberforcatsServicesProfit instead of ServicesProfit for $VDLROOT/com.uberforcats/services/profit).

If you are creating multiple Swift modules for a given $VDLROOT then just place swiftmodule files at the logical boundaries. For eample, we do this for v.io/v23 to be exported to the VanadiumCore framework, but everything under v.io/v23/services lives in the VanadiumServices framework.

func (SwiftConfig) VDLIsZero

func (x SwiftConfig) VDLIsZero() bool

func (*SwiftConfig) VDLRead

func (x *SwiftConfig) VDLRead(dec vdl.Decoder) error

func (SwiftConfig) VDLReflect

func (SwiftConfig) VDLReflect(struct {
	Name string `vdl:"vdltool.SwiftConfig"`
})

func (SwiftConfig) VDLWrite

func (x SwiftConfig) VDLWrite(enc vdl.Encoder) error

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL