package hcl

Import Path
	github.com/hashicorp/hcl (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package

Involved Source Files

	      decoder.go
	   d➜ hcl.go
		Package hcl decodes HCL into usable Go structures.

		hcl input can come in either pure HCL format or JSON format.
		It can be parsed into an AST, and then decoded into a structure,
		or it can be decoded directly from a string into a structure.

		If you choose to parse HCL into a raw AST, the benefit is that you
		can write custom visitor implementations to implement custom
		semantic checks. By default, HCL does not perform any semantic
		checks.

	      lex.go
	      parse.go
Package-Level Type Names (total 2, neither is exported)

	/* sort exporteds by: alphabet | popularity */
	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type decoder (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			stack []reflect.Kind
		Methods (total 10, none are exported)
			/* 10 unexporteds ... *//* 10 unexporteds: */
			(*T) decode(name string, node ast.Node, result reflect.Value) error
			(*T) decodeBool(name string, node ast.Node, result reflect.Value) error
			(*T) decodeFloat(name string, node ast.Node, result reflect.Value) error
			(*T) decodeInt(name string, node ast.Node, result reflect.Value) error
			(*T) decodeInterface(name string, node ast.Node, result reflect.Value) error
			(*T) decodeMap(name string, node ast.Node, result reflect.Value) error
			(*T) decodePtr(name string, node ast.Node, result reflect.Value) error
			(*T) decodeSlice(name string, node ast.Node, result reflect.Value) error
			(*T) decodeString(name string, node ast.Node, result reflect.Value) error
			(*T) decodeStruct(name string, node ast.Node, result reflect.Value) error

	 type lexModeValue byte (basic type)

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func lexMode(v []byte) lexModeValue
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			const lexModeHcl
			const lexModeJson
			const lexModeUnknown


Package-Level Functions (total 10, in which 6 are exported)

	 func Decode(out interface{}, in string) error
		Decode reads the given input and decodes it into the structure
		given by `out`.

	 func DecodeObject(out interface{}, n ast.Node) error
		DecodeObject is a lower-level version of Decode. It decodes a
		raw Object into the given output.

	 func Parse(input string) (*ast.File, error)
		Parse parses the given input and returns the root object.

		The input format can be either HCL or JSON.

	 func ParseBytes(in []byte) (*ast.File, error)
		ParseBytes accepts as input byte slice and returns ast tree.

		Input can be either JSON or HCL

	 func ParseString(input string) (*ast.File, error)
		ParseString accepts input as a string and returns ast tree.

	 func Unmarshal(bs []byte, v interface{}) error
		Unmarshal accepts a byte slice as input and writes the
		data to the value pointed to by v.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func expandObject(node ast.Node, result reflect.Value) ast.Node
		expandObject detects if an ambiguous JSON object was flattened to a List which
		should be decoded into a struct, and expands the ast to properly deocode.

	 func findNodeType() reflect.Type
		findNodeType returns the type of ast.Node

	 func lexMode(v []byte) lexModeValue
		lexMode returns whether we're going to be parsing in JSON
		mode or HCL mode.

	 func parse(in []byte) (*ast.File, error)
Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var nodeType reflect.Type
		nodeType holds a reference to the type of ast.Node


Package-Level Constants (total 4, none are exported)

	/* 4 unexporteds ... *//* 4 unexporteds: */
	const lexModeHcl lexModeValue = 1
	const lexModeJson lexModeValue = 2
	const lexModeUnknown lexModeValue = 0
	const tagName = "hcl"
		This is the tag to use with structures to have settings for HCL

The pages are generated with Golds v0.3.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.