1327 lines
42 KiB
Go
1327 lines
42 KiB
Go
// Code generated by protoc-gen-go. DO NOT EDIT.
|
|
// source: hcl_spec.proto
|
|
|
|
package hclspec
|
|
|
|
/*
|
|
Spec allows exposing the specification for an HCL body, allowing for parsing and
|
|
validation.
|
|
|
|
Certain expressions within a specification may use the following functions.
|
|
The documentation for each spec type above specifies where functions may
|
|
be used.
|
|
|
|
`abs(number)` returns the absolute (positive) value of the given number.
|
|
`coalesce(vals...)` returns the first non-null value given.
|
|
`concat(lists...)` concatenates together all of the given lists to produce a new list.
|
|
`hasindex(val, idx)` returns true if the expression `val[idx]` could succeed.
|
|
`int(number)` returns the integer portion of the given number, rounding towards zero.
|
|
`jsondecode(str)` interprets the given string as JSON and returns the resulting data structure.
|
|
`jsonencode(val)` returns a JSON-serialized version of the given value.
|
|
`length(collection)` returns the number of elements in the given collection (list, set, map, object, or tuple).
|
|
`lower(string)` returns the given string with all uppercase letters converted to lowercase.
|
|
`max(numbers...)` returns the greatest of the given numbers.
|
|
`min(numbers...)` returns the smallest of the given numbers.
|
|
`reverse(string)` returns the given string with all of the characters in reverse order.
|
|
`strlen(string)` returns the number of characters in the given string.
|
|
`substr(string, offset, length)` returns the requested substring of the given string.
|
|
`upper(string)` returns the given string with all lowercase letters converted to uppercase.
|
|
|
|
## Type Expressions
|
|
|
|
Type expressions are used to describe the expected type of an attribute, as
|
|
an additional validation constraint.
|
|
|
|
A type expression uses primitive type names and compound type constructors.
|
|
A type constructor builds a new type based on one or more type expression
|
|
arguments.
|
|
|
|
The following type names and type constructors are supported:
|
|
|
|
`any` is a wildcard that accepts a value of any type. (In HCL terms, this
|
|
is the _dynamic pseudo-type_.)
|
|
`string` is a Unicode string.
|
|
`number` is an arbitrary-precision floating point number.
|
|
`bool` is a boolean value (`true` or `false`)
|
|
`list(element_type)` constructs a list type with the given element type
|
|
`set(element_type)` constructs a set type with the given element type
|
|
`map(element_type)` constructs a map type with the given element type
|
|
`object({name1 = element_type, name2 = element_type, ...})` constructs
|
|
an object type with the given attribute types.
|
|
`tuple([element_type, element_type, ...])` constructs a tuple type with
|
|
the given element types. This can be used, for example, to require an
|
|
array with a particular number of elements, or with elements of different
|
|
types.
|
|
|
|
`null` is a valid value of any type, and not a type itself.
|
|
*/
|
|
|
|
import proto "github.com/golang/protobuf/proto"
|
|
import fmt "fmt"
|
|
import math "math"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
|
|
|
|
// Spec defines the available specification types.
|
|
type Spec struct {
|
|
// Types that are valid to be assigned to Block:
|
|
// *Spec_Object
|
|
// *Spec_Array
|
|
// *Spec_Attr
|
|
// *Spec_BlockValue
|
|
// *Spec_BlockAttrs
|
|
// *Spec_BlockList
|
|
// *Spec_BlockSet
|
|
// *Spec_BlockMap
|
|
// *Spec_Default
|
|
// *Spec_Literal
|
|
Block isSpec_Block `protobuf_oneof:"block"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Spec) Reset() { *m = Spec{} }
|
|
func (m *Spec) String() string { return proto.CompactTextString(m) }
|
|
func (*Spec) ProtoMessage() {}
|
|
func (*Spec) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{0}
|
|
}
|
|
func (m *Spec) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Spec.Unmarshal(m, b)
|
|
}
|
|
func (m *Spec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Spec.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Spec) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Spec.Merge(dst, src)
|
|
}
|
|
func (m *Spec) XXX_Size() int {
|
|
return xxx_messageInfo_Spec.Size(m)
|
|
}
|
|
func (m *Spec) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Spec.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Spec proto.InternalMessageInfo
|
|
|
|
type isSpec_Block interface {
|
|
isSpec_Block()
|
|
}
|
|
|
|
type Spec_Object struct {
|
|
Object *Object `protobuf:"bytes,1,opt,name=object,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_Array struct {
|
|
Array *Array `protobuf:"bytes,2,opt,name=array,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_Attr struct {
|
|
Attr *Attr `protobuf:"bytes,3,opt,name=Attr,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_BlockValue struct {
|
|
BlockValue *Block `protobuf:"bytes,4,opt,name=block_value,json=blockValue,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_BlockAttrs struct {
|
|
BlockAttrs *BlockAttrs `protobuf:"bytes,5,opt,name=block_attrs,json=blockAttrs,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_BlockList struct {
|
|
BlockList *BlockList `protobuf:"bytes,6,opt,name=block_list,json=blockList,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_BlockSet struct {
|
|
BlockSet *BlockSet `protobuf:"bytes,7,opt,name=block_set,json=blockSet,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_BlockMap struct {
|
|
BlockMap *BlockMap `protobuf:"bytes,8,opt,name=block_map,json=blockMap,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_Default struct {
|
|
Default *Default `protobuf:"bytes,9,opt,name=default,proto3,oneof"`
|
|
}
|
|
|
|
type Spec_Literal struct {
|
|
Literal *Literal `protobuf:"bytes,10,opt,name=literal,proto3,oneof"`
|
|
}
|
|
|
|
func (*Spec_Object) isSpec_Block() {}
|
|
|
|
func (*Spec_Array) isSpec_Block() {}
|
|
|
|
func (*Spec_Attr) isSpec_Block() {}
|
|
|
|
func (*Spec_BlockValue) isSpec_Block() {}
|
|
|
|
func (*Spec_BlockAttrs) isSpec_Block() {}
|
|
|
|
func (*Spec_BlockList) isSpec_Block() {}
|
|
|
|
func (*Spec_BlockSet) isSpec_Block() {}
|
|
|
|
func (*Spec_BlockMap) isSpec_Block() {}
|
|
|
|
func (*Spec_Default) isSpec_Block() {}
|
|
|
|
func (*Spec_Literal) isSpec_Block() {}
|
|
|
|
func (m *Spec) GetBlock() isSpec_Block {
|
|
if m != nil {
|
|
return m.Block
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetObject() *Object {
|
|
if x, ok := m.GetBlock().(*Spec_Object); ok {
|
|
return x.Object
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetArray() *Array {
|
|
if x, ok := m.GetBlock().(*Spec_Array); ok {
|
|
return x.Array
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetAttr() *Attr {
|
|
if x, ok := m.GetBlock().(*Spec_Attr); ok {
|
|
return x.Attr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetBlockValue() *Block {
|
|
if x, ok := m.GetBlock().(*Spec_BlockValue); ok {
|
|
return x.BlockValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetBlockAttrs() *BlockAttrs {
|
|
if x, ok := m.GetBlock().(*Spec_BlockAttrs); ok {
|
|
return x.BlockAttrs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetBlockList() *BlockList {
|
|
if x, ok := m.GetBlock().(*Spec_BlockList); ok {
|
|
return x.BlockList
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetBlockSet() *BlockSet {
|
|
if x, ok := m.GetBlock().(*Spec_BlockSet); ok {
|
|
return x.BlockSet
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetBlockMap() *BlockMap {
|
|
if x, ok := m.GetBlock().(*Spec_BlockMap); ok {
|
|
return x.BlockMap
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetDefault() *Default {
|
|
if x, ok := m.GetBlock().(*Spec_Default); ok {
|
|
return x.Default
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Spec) GetLiteral() *Literal {
|
|
if x, ok := m.GetBlock().(*Spec_Literal); ok {
|
|
return x.Literal
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofFuncs is for the internal use of the proto package.
|
|
func (*Spec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
|
|
return _Spec_OneofMarshaler, _Spec_OneofUnmarshaler, _Spec_OneofSizer, []interface{}{
|
|
(*Spec_Object)(nil),
|
|
(*Spec_Array)(nil),
|
|
(*Spec_Attr)(nil),
|
|
(*Spec_BlockValue)(nil),
|
|
(*Spec_BlockAttrs)(nil),
|
|
(*Spec_BlockList)(nil),
|
|
(*Spec_BlockSet)(nil),
|
|
(*Spec_BlockMap)(nil),
|
|
(*Spec_Default)(nil),
|
|
(*Spec_Literal)(nil),
|
|
}
|
|
}
|
|
|
|
func _Spec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
|
|
m := msg.(*Spec)
|
|
// block
|
|
switch x := m.Block.(type) {
|
|
case *Spec_Object:
|
|
b.EncodeVarint(1<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Object); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_Array:
|
|
b.EncodeVarint(2<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Array); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_Attr:
|
|
b.EncodeVarint(3<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Attr); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_BlockValue:
|
|
b.EncodeVarint(4<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BlockValue); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_BlockAttrs:
|
|
b.EncodeVarint(5<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BlockAttrs); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_BlockList:
|
|
b.EncodeVarint(6<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BlockList); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_BlockSet:
|
|
b.EncodeVarint(7<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BlockSet); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_BlockMap:
|
|
b.EncodeVarint(8<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.BlockMap); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_Default:
|
|
b.EncodeVarint(9<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Default); err != nil {
|
|
return err
|
|
}
|
|
case *Spec_Literal:
|
|
b.EncodeVarint(10<<3 | proto.WireBytes)
|
|
if err := b.EncodeMessage(x.Literal); err != nil {
|
|
return err
|
|
}
|
|
case nil:
|
|
default:
|
|
return fmt.Errorf("Spec.Block has unexpected type %T", x)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func _Spec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
|
|
m := msg.(*Spec)
|
|
switch tag {
|
|
case 1: // block.object
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Object)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_Object{msg}
|
|
return true, err
|
|
case 2: // block.array
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Array)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_Array{msg}
|
|
return true, err
|
|
case 3: // block.Attr
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Attr)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_Attr{msg}
|
|
return true, err
|
|
case 4: // block.block_value
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Block)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_BlockValue{msg}
|
|
return true, err
|
|
case 5: // block.block_attrs
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(BlockAttrs)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_BlockAttrs{msg}
|
|
return true, err
|
|
case 6: // block.block_list
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(BlockList)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_BlockList{msg}
|
|
return true, err
|
|
case 7: // block.block_set
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(BlockSet)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_BlockSet{msg}
|
|
return true, err
|
|
case 8: // block.block_map
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(BlockMap)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_BlockMap{msg}
|
|
return true, err
|
|
case 9: // block.default
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Default)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_Default{msg}
|
|
return true, err
|
|
case 10: // block.literal
|
|
if wire != proto.WireBytes {
|
|
return true, proto.ErrInternalBadWireType
|
|
}
|
|
msg := new(Literal)
|
|
err := b.DecodeMessage(msg)
|
|
m.Block = &Spec_Literal{msg}
|
|
return true, err
|
|
default:
|
|
return false, nil
|
|
}
|
|
}
|
|
|
|
func _Spec_OneofSizer(msg proto.Message) (n int) {
|
|
m := msg.(*Spec)
|
|
// block
|
|
switch x := m.Block.(type) {
|
|
case *Spec_Object:
|
|
s := proto.Size(x.Object)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_Array:
|
|
s := proto.Size(x.Array)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_Attr:
|
|
s := proto.Size(x.Attr)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_BlockValue:
|
|
s := proto.Size(x.BlockValue)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_BlockAttrs:
|
|
s := proto.Size(x.BlockAttrs)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_BlockList:
|
|
s := proto.Size(x.BlockList)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_BlockSet:
|
|
s := proto.Size(x.BlockSet)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_BlockMap:
|
|
s := proto.Size(x.BlockMap)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_Default:
|
|
s := proto.Size(x.Default)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case *Spec_Literal:
|
|
s := proto.Size(x.Literal)
|
|
n += 1 // tag and wire
|
|
n += proto.SizeVarint(uint64(s))
|
|
n += s
|
|
case nil:
|
|
default:
|
|
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
|
|
}
|
|
return n
|
|
}
|
|
|
|
// Attr spec type reads the value of an attribute in the current body
|
|
// and returns that value as its result. It also creates validation constraints
|
|
// for the given attribute name and its value.
|
|
//
|
|
// ```hcl
|
|
// Attr {
|
|
// name = "document_root"
|
|
// type = string
|
|
// required = true
|
|
// }
|
|
// ```
|
|
//
|
|
// `Attr` spec blocks accept the following arguments:
|
|
//
|
|
// `name` (required) - The attribute name to expect within the HCL input file.
|
|
// This may be omitted when a default name selector is created by a parent
|
|
// `Object` spec, if the input attribute name should match the output JSON
|
|
// object property name.
|
|
//
|
|
// `type` (optional) - A [type expression](#type-expressions) that the given
|
|
// attribute value must conform to. If this argument is set, `hcldec` will
|
|
// automatically convert the given input value to this type or produce an
|
|
// error if that is not possible.
|
|
//
|
|
// `required` (optional) - If set to `true`, `hcldec` will produce an error
|
|
// if a value is not provided for the source attribute.
|
|
//
|
|
// `Attr` is a leaf spec type, so no nested spec blocks are permitted.
|
|
type Attr struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
|
|
Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Attr) Reset() { *m = Attr{} }
|
|
func (m *Attr) String() string { return proto.CompactTextString(m) }
|
|
func (*Attr) ProtoMessage() {}
|
|
func (*Attr) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{1}
|
|
}
|
|
func (m *Attr) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Attr.Unmarshal(m, b)
|
|
}
|
|
func (m *Attr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Attr.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Attr) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Attr.Merge(dst, src)
|
|
}
|
|
func (m *Attr) XXX_Size() int {
|
|
return xxx_messageInfo_Attr.Size(m)
|
|
}
|
|
func (m *Attr) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Attr.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Attr proto.InternalMessageInfo
|
|
|
|
func (m *Attr) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Attr) GetType() string {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Attr) GetRequired() bool {
|
|
if m != nil {
|
|
return m.Required
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Block spec type applies one nested spec block to the contents of a
|
|
// block within the current body and returns the result of that spec. It also
|
|
// creates validation constraints for the given block type name.
|
|
//
|
|
// ```hcl
|
|
// Block {
|
|
// name = "logging"
|
|
//
|
|
// Object {
|
|
// Attr "level" {
|
|
// type = string
|
|
// }
|
|
// Attr "file" {
|
|
// type = string
|
|
// }
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// `Block` spec blocks accept the following arguments:
|
|
//
|
|
// `name` (required) - The block type name to expect within the HCL
|
|
// input file. This may be omitted when a default name selector is created
|
|
// by a parent `Object` spec, if the input block type name should match the
|
|
// output JSON object property name.
|
|
//
|
|
// `required` (optional) - If set to `true`, `hcldec` will produce an error
|
|
// if a block of the specified type is not present in the current body.
|
|
//
|
|
// `Block` creates a validation constraint that there must be zero or one blocks
|
|
// of the given type name, or exactly one if `required` is set.
|
|
//
|
|
// `Block` expects a single nested spec block, which is applied to the body of
|
|
// the block of the given type when it is present.
|
|
//
|
|
type Block struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Required bool `protobuf:"varint,2,opt,name=required,proto3" json:"required,omitempty"`
|
|
Nested *Spec `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Block) Reset() { *m = Block{} }
|
|
func (m *Block) String() string { return proto.CompactTextString(m) }
|
|
func (*Block) ProtoMessage() {}
|
|
func (*Block) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{2}
|
|
}
|
|
func (m *Block) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Block.Unmarshal(m, b)
|
|
}
|
|
func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Block.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Block) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Block.Merge(dst, src)
|
|
}
|
|
func (m *Block) XXX_Size() int {
|
|
return xxx_messageInfo_Block.Size(m)
|
|
}
|
|
func (m *Block) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Block.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Block proto.InternalMessageInfo
|
|
|
|
func (m *Block) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *Block) GetRequired() bool {
|
|
if m != nil {
|
|
return m.Required
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *Block) GetNested() *Spec {
|
|
if m != nil {
|
|
return m.Nested
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//
|
|
// The BlockAttrs spec type is similar to an Attr spec block of a map type,
|
|
// but it produces a map from the attributes of a block rather than from an
|
|
// attribute's expression.
|
|
//
|
|
// ```hcl
|
|
// BlockAttrs {
|
|
// name = "variables"
|
|
// type = string
|
|
// required = false
|
|
// }
|
|
// ```
|
|
//
|
|
// This allows a map with user-defined keys to be produced within block syntax,
|
|
// but due to the constraints of that syntax it also means that the user will
|
|
// be unable to dynamically-generate either individual key names using key
|
|
// expressions or the entire map value using a `for` expression.
|
|
//
|
|
// `BlockAttrs` spec blocks accept the following arguments:
|
|
//
|
|
// `name` (required) - The block type name to expect within the HCL
|
|
// input file. This may be omitted when a default name selector is created
|
|
// by a parent `object` spec, if the input block type name should match the
|
|
// output JSON object property name.
|
|
//
|
|
// `type` (required) - The value type to require for each of the
|
|
// attributes within a matched block. The resulting value will be a JSON
|
|
// object whose property values are of this type.
|
|
//
|
|
// `required` (optional) - If `true`, an error will be produced if a block
|
|
// of the given type is not present. If `false` -- the default -- an absent
|
|
// block will be indicated by producing `null`.
|
|
type BlockAttrs struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
|
|
Required bool `protobuf:"varint,3,opt,name=required,proto3" json:"required,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *BlockAttrs) Reset() { *m = BlockAttrs{} }
|
|
func (m *BlockAttrs) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockAttrs) ProtoMessage() {}
|
|
func (*BlockAttrs) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{3}
|
|
}
|
|
func (m *BlockAttrs) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_BlockAttrs.Unmarshal(m, b)
|
|
}
|
|
func (m *BlockAttrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_BlockAttrs.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *BlockAttrs) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockAttrs.Merge(dst, src)
|
|
}
|
|
func (m *BlockAttrs) XXX_Size() int {
|
|
return xxx_messageInfo_BlockAttrs.Size(m)
|
|
}
|
|
func (m *BlockAttrs) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockAttrs.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockAttrs proto.InternalMessageInfo
|
|
|
|
func (m *BlockAttrs) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockAttrs) GetType() string {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockAttrs) GetRequired() bool {
|
|
if m != nil {
|
|
return m.Required
|
|
}
|
|
return false
|
|
}
|
|
|
|
// BlockList spec type is similar to `Block`, but it accepts zero or
|
|
// more blocks of a specified type rather than requiring zero or one. The
|
|
// result is a JSON array with one entry per block of the given type.
|
|
//
|
|
// ```hcl
|
|
// BlockList {
|
|
// name = "log_file"
|
|
//
|
|
// Object {
|
|
// Attr "level" {
|
|
// type = string
|
|
// }
|
|
// Attr "filename" {
|
|
// type = string
|
|
// required = true
|
|
// }
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// `BlockList` spec blocks accept the following arguments:
|
|
//
|
|
// `name` (required) - The block type name to expect within the HCL
|
|
// input file. This may be omitted when a default name selector is created
|
|
// by a parent `Object` spec, if the input block type name should match the
|
|
// output JSON object property name.
|
|
//
|
|
// `min_items` (optional) - If set to a number greater than zero, `hcldec` will
|
|
// produce an error if fewer than the given number of blocks are present.
|
|
//
|
|
// `max_items` (optional) - If set to a number greater than zero, `hcldec` will
|
|
// produce an error if more than the given number of blocks are present. This
|
|
// attribute must be greater than or equal to `min_items` if both are set.
|
|
//
|
|
// `Block` creates a validation constraint on the number of blocks of the given
|
|
// type that must be present.
|
|
//
|
|
// `Block` expects a single nested spec block, which is applied to the body of
|
|
// each matching block to produce the resulting list items.
|
|
//
|
|
type BlockList struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
MinItems uint64 `protobuf:"varint,2,opt,name=min_items,json=minItems,proto3" json:"min_items,omitempty"`
|
|
MaxItems uint64 `protobuf:"varint,3,opt,name=max_items,json=maxItems,proto3" json:"max_items,omitempty"`
|
|
Nested *Spec `protobuf:"bytes,4,opt,name=nested,proto3" json:"nested,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *BlockList) Reset() { *m = BlockList{} }
|
|
func (m *BlockList) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockList) ProtoMessage() {}
|
|
func (*BlockList) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{4}
|
|
}
|
|
func (m *BlockList) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_BlockList.Unmarshal(m, b)
|
|
}
|
|
func (m *BlockList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_BlockList.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *BlockList) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockList.Merge(dst, src)
|
|
}
|
|
func (m *BlockList) XXX_Size() int {
|
|
return xxx_messageInfo_BlockList.Size(m)
|
|
}
|
|
func (m *BlockList) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockList.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockList proto.InternalMessageInfo
|
|
|
|
func (m *BlockList) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockList) GetMinItems() uint64 {
|
|
if m != nil {
|
|
return m.MinItems
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *BlockList) GetMaxItems() uint64 {
|
|
if m != nil {
|
|
return m.MaxItems
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *BlockList) GetNested() *Spec {
|
|
if m != nil {
|
|
return m.Nested
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// BlockSet spec type behaves the same as BlockList except that
|
|
// the result is in no specific order and any duplicate items are removed.
|
|
//
|
|
// ```hcl
|
|
// BlockSet {
|
|
// name = "log_file"
|
|
//
|
|
// Object {
|
|
// Attr "level" {
|
|
// type = string
|
|
// }
|
|
// Attr "filename" {
|
|
// type = string
|
|
// required = true
|
|
// }
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// The contents of `BlockSet` are the same as for `BlockList`.
|
|
//
|
|
type BlockSet struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
MinItems uint64 `protobuf:"varint,2,opt,name=min_items,json=minItems,proto3" json:"min_items,omitempty"`
|
|
MaxItems uint64 `protobuf:"varint,3,opt,name=max_items,json=maxItems,proto3" json:"max_items,omitempty"`
|
|
Nested *Spec `protobuf:"bytes,4,opt,name=nested,proto3" json:"nested,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *BlockSet) Reset() { *m = BlockSet{} }
|
|
func (m *BlockSet) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockSet) ProtoMessage() {}
|
|
func (*BlockSet) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{5}
|
|
}
|
|
func (m *BlockSet) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_BlockSet.Unmarshal(m, b)
|
|
}
|
|
func (m *BlockSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_BlockSet.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *BlockSet) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockSet.Merge(dst, src)
|
|
}
|
|
func (m *BlockSet) XXX_Size() int {
|
|
return xxx_messageInfo_BlockSet.Size(m)
|
|
}
|
|
func (m *BlockSet) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockSet.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockSet proto.InternalMessageInfo
|
|
|
|
func (m *BlockSet) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockSet) GetMinItems() uint64 {
|
|
if m != nil {
|
|
return m.MinItems
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *BlockSet) GetMaxItems() uint64 {
|
|
if m != nil {
|
|
return m.MaxItems
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *BlockSet) GetNested() *Spec {
|
|
if m != nil {
|
|
return m.Nested
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// BlockMap spec type is similar to `Block`, but it accepts zero or
|
|
// more blocks of a specified type rather than requiring zero or one. The
|
|
// result is a JSON object, or possibly multiple nested JSON objects, whose
|
|
// properties are derived from the labels set on each matching block.
|
|
//
|
|
// ```hcl
|
|
// BlockMap {
|
|
// name = "log_file"
|
|
// labels = ["filename"]
|
|
//
|
|
// Object {
|
|
// Attr "level" {
|
|
// type = string
|
|
// required = true
|
|
// }
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// `BlockMap` spec blocks accept the following arguments:
|
|
//
|
|
// `name` (required) - The block type name to expect within the HCL
|
|
// input file. This may be omitted when a default name selector is created
|
|
// by a parent `Object` spec, if the input block type name should match the
|
|
// output JSON object property name.
|
|
//
|
|
// `labels` (required) - A list of user-oriented block label names. Each entry
|
|
// in this list creates one level of object within the output value, and
|
|
// requires one additional block header label on any child block of this type.
|
|
// Block header labels are the quoted strings that appear after the block type
|
|
// name but before the opening `{`.
|
|
//
|
|
// `Block` creates a validation constraint on the number of labels that blocks
|
|
// of the given type must have.
|
|
//
|
|
// `Block` expects a single nested spec block, which is applied to the body of
|
|
// each matching block to produce the resulting map items.
|
|
//
|
|
type BlockMap struct {
|
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
|
Labels []string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty"`
|
|
Nested *Spec `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *BlockMap) Reset() { *m = BlockMap{} }
|
|
func (m *BlockMap) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockMap) ProtoMessage() {}
|
|
func (*BlockMap) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{6}
|
|
}
|
|
func (m *BlockMap) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_BlockMap.Unmarshal(m, b)
|
|
}
|
|
func (m *BlockMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_BlockMap.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *BlockMap) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockMap.Merge(dst, src)
|
|
}
|
|
func (m *BlockMap) XXX_Size() int {
|
|
return xxx_messageInfo_BlockMap.Size(m)
|
|
}
|
|
func (m *BlockMap) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockMap.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockMap proto.InternalMessageInfo
|
|
|
|
func (m *BlockMap) GetName() string {
|
|
if m != nil {
|
|
return m.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockMap) GetLabels() []string {
|
|
if m != nil {
|
|
return m.Labels
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockMap) GetNested() *Spec {
|
|
if m != nil {
|
|
return m.Nested
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Literal spec type returns a given literal value, and creates no
|
|
// validation constraints. It is most commonly used with the `Default` spec
|
|
// type to create a fallback value, but can also be used e.g. to fill out
|
|
// required properties in an `Object` spec that do not correspond to any
|
|
// construct in the input configuration.
|
|
//
|
|
// ```hcl
|
|
// Literal {
|
|
// value = "hello world"
|
|
// }
|
|
// ```
|
|
//
|
|
// `Literal` spec blocks accept the following argument:
|
|
//
|
|
// `value` (required) - The value to return. This attribute may be an expression
|
|
// that uses [functions](#spec-definition-functions).
|
|
//
|
|
// `Literal` is a leaf spec type, so no nested spec blocks are permitted.
|
|
type Literal struct {
|
|
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Literal) Reset() { *m = Literal{} }
|
|
func (m *Literal) String() string { return proto.CompactTextString(m) }
|
|
func (*Literal) ProtoMessage() {}
|
|
func (*Literal) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{7}
|
|
}
|
|
func (m *Literal) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Literal.Unmarshal(m, b)
|
|
}
|
|
func (m *Literal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Literal.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Literal) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Literal.Merge(dst, src)
|
|
}
|
|
func (m *Literal) XXX_Size() int {
|
|
return xxx_messageInfo_Literal.Size(m)
|
|
}
|
|
func (m *Literal) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Literal.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Literal proto.InternalMessageInfo
|
|
|
|
func (m *Literal) GetValue() string {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Default spec type evaluates a sequence of nested specs in turn and
|
|
// returns the result of the first one that produces a non-null value.
|
|
// It creates no validation constraints of its own, but passes on the validation
|
|
// constraints from its first nested block.
|
|
//
|
|
// ```hcl
|
|
// Default {
|
|
// Attr {
|
|
// name = "private"
|
|
// type = bool
|
|
// }
|
|
// Literal {
|
|
// value = false
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// A `Default` spec block must have at least one nested spec block, and should
|
|
// generally have at least two since otherwise the `Default` wrapper is a no-op.
|
|
//
|
|
// The second and any subsequent spec blocks are _fallback_ specs. These exhibit
|
|
// their usual behavior but are not able to impose validation constraints on the
|
|
// current body since they are not evaluated unless all prior specs produce
|
|
// `null` as their result.
|
|
//
|
|
type Default struct {
|
|
Primary *Spec `protobuf:"bytes,1,opt,name=primary,proto3" json:"primary,omitempty"`
|
|
Default *Spec `protobuf:"bytes,2,opt,name=default,proto3" json:"default,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Default) Reset() { *m = Default{} }
|
|
func (m *Default) String() string { return proto.CompactTextString(m) }
|
|
func (*Default) ProtoMessage() {}
|
|
func (*Default) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{8}
|
|
}
|
|
func (m *Default) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Default.Unmarshal(m, b)
|
|
}
|
|
func (m *Default) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Default.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Default) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Default.Merge(dst, src)
|
|
}
|
|
func (m *Default) XXX_Size() int {
|
|
return xxx_messageInfo_Default.Size(m)
|
|
}
|
|
func (m *Default) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Default.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Default proto.InternalMessageInfo
|
|
|
|
func (m *Default) GetPrimary() *Spec {
|
|
if m != nil {
|
|
return m.Primary
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Default) GetDefault() *Spec {
|
|
if m != nil {
|
|
return m.Default
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Object spec type is the most commonly used at the root of a spec file.
|
|
// Its result is a JSON object whose properties are set based on any nested
|
|
// spec blocks:
|
|
//
|
|
// ```hcl
|
|
// Object {
|
|
// Attr "name" {
|
|
// type = "string"
|
|
// }
|
|
// Block "address" {
|
|
// Object {
|
|
// Attr "street" {
|
|
// type = "string"
|
|
// }
|
|
// # ...
|
|
// }
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// Nested spec blocks inside `Object` must always have an extra block label
|
|
// `"name"`, `"address"` and `"street"` in the above example) that specifies
|
|
// the name of the property that should be created in the JSON object result.
|
|
// This label also acts as a default name selector for the nested spec, allowing
|
|
// the `Attr` blocks in the above example to omit the usually-required `name`
|
|
// argument in cases where the HCL input name and JSON output name are the same.
|
|
//
|
|
// An `Object` spec block creates no validation constraints, but it passes on
|
|
// any validation constraints created by the nested specs.
|
|
type Object struct {
|
|
Attributes map[string]*Spec `protobuf:"bytes,1,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Object) Reset() { *m = Object{} }
|
|
func (m *Object) String() string { return proto.CompactTextString(m) }
|
|
func (*Object) ProtoMessage() {}
|
|
func (*Object) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{9}
|
|
}
|
|
func (m *Object) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Object.Unmarshal(m, b)
|
|
}
|
|
func (m *Object) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Object.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Object) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Object.Merge(dst, src)
|
|
}
|
|
func (m *Object) XXX_Size() int {
|
|
return xxx_messageInfo_Object.Size(m)
|
|
}
|
|
func (m *Object) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Object.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Object proto.InternalMessageInfo
|
|
|
|
func (m *Object) GetAttributes() map[string]*Spec {
|
|
if m != nil {
|
|
return m.Attributes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Array spec type produces a JSON array whose elements are set based on
|
|
// any nested spec blocks:
|
|
//
|
|
// ```hcl
|
|
// Array {
|
|
// Attr {
|
|
// name = "first_element"
|
|
// type = "string"
|
|
// }
|
|
// Attr {
|
|
// name = "second_element"
|
|
// type = "string"
|
|
// }
|
|
// }
|
|
// ```
|
|
//
|
|
// An `Array` spec block creates no validation constraints, but it passes on
|
|
// any validation constraints created by the nested specs.
|
|
type Array struct {
|
|
Values []*Spec `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *Array) Reset() { *m = Array{} }
|
|
func (m *Array) String() string { return proto.CompactTextString(m) }
|
|
func (*Array) ProtoMessage() {}
|
|
func (*Array) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_hcl_spec_b17a3e0d58741859, []int{10}
|
|
}
|
|
func (m *Array) XXX_Unmarshal(b []byte) error {
|
|
return xxx_messageInfo_Array.Unmarshal(m, b)
|
|
}
|
|
func (m *Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
return xxx_messageInfo_Array.Marshal(b, m, deterministic)
|
|
}
|
|
func (dst *Array) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Array.Merge(dst, src)
|
|
}
|
|
func (m *Array) XXX_Size() int {
|
|
return xxx_messageInfo_Array.Size(m)
|
|
}
|
|
func (m *Array) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Array.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Array proto.InternalMessageInfo
|
|
|
|
func (m *Array) GetValues() []*Spec {
|
|
if m != nil {
|
|
return m.Values
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*Spec)(nil), "hashicorp.nomad.plugins.shared.hclspec.Spec")
|
|
proto.RegisterType((*Attr)(nil), "hashicorp.nomad.plugins.shared.hclspec.Attr")
|
|
proto.RegisterType((*Block)(nil), "hashicorp.nomad.plugins.shared.hclspec.Block")
|
|
proto.RegisterType((*BlockAttrs)(nil), "hashicorp.nomad.plugins.shared.hclspec.BlockAttrs")
|
|
proto.RegisterType((*BlockList)(nil), "hashicorp.nomad.plugins.shared.hclspec.BlockList")
|
|
proto.RegisterType((*BlockSet)(nil), "hashicorp.nomad.plugins.shared.hclspec.BlockSet")
|
|
proto.RegisterType((*BlockMap)(nil), "hashicorp.nomad.plugins.shared.hclspec.BlockMap")
|
|
proto.RegisterType((*Literal)(nil), "hashicorp.nomad.plugins.shared.hclspec.Literal")
|
|
proto.RegisterType((*Default)(nil), "hashicorp.nomad.plugins.shared.hclspec.Default")
|
|
proto.RegisterType((*Object)(nil), "hashicorp.nomad.plugins.shared.hclspec.Object")
|
|
proto.RegisterMapType((map[string]*Spec)(nil), "hashicorp.nomad.plugins.shared.hclspec.Object.AttributesEntry")
|
|
proto.RegisterType((*Array)(nil), "hashicorp.nomad.plugins.shared.hclspec.Array")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("hcl_spec.proto", fileDescriptor_hcl_spec_b17a3e0d58741859) }
|
|
|
|
var fileDescriptor_hcl_spec_b17a3e0d58741859 = []byte{
|
|
// 617 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x96, 0xcd, 0x6e, 0xd3, 0x40,
|
|
0x10, 0xc7, 0xe3, 0xc4, 0x9f, 0x53, 0x09, 0xd0, 0x0a, 0x21, 0xab, 0x1c, 0xa8, 0x7c, 0x40, 0x3d,
|
|
0x80, 0x81, 0x72, 0x41, 0x1c, 0x90, 0x1a, 0xb5, 0xc8, 0x40, 0xa3, 0x56, 0x5b, 0xc1, 0x81, 0x03,
|
|
0xd1, 0xda, 0x59, 0x88, 0x89, 0xbf, 0xd8, 0xdd, 0xa0, 0x46, 0x82, 0x07, 0xe1, 0x00, 0x3c, 0x15,
|
|
0xef, 0x83, 0xf6, 0xc3, 0x49, 0x41, 0x39, 0xc4, 0xa1, 0x07, 0x6e, 0x3b, 0x3b, 0xf9, 0xff, 0x3c,
|
|
0xb3, 0x3b, 0xb3, 0x13, 0xb8, 0x36, 0xcd, 0x8a, 0x31, 0x6f, 0x68, 0x16, 0x37, 0xac, 0x16, 0x35,
|
|
0xba, 0x3b, 0x25, 0x7c, 0x9a, 0x67, 0x35, 0x6b, 0xe2, 0xaa, 0x2e, 0xc9, 0x24, 0x6e, 0x8a, 0xf9,
|
|
0x87, 0xbc, 0xe2, 0x31, 0x9f, 0x12, 0x46, 0x27, 0xf1, 0x34, 0x2b, 0xe4, 0xaf, 0xa3, 0xef, 0x2e,
|
|
0xd8, 0xe7, 0x0d, 0xcd, 0x50, 0x02, 0x6e, 0x9d, 0x7e, 0xa4, 0x99, 0x08, 0xad, 0x3d, 0x6b, 0x7f,
|
|
0xe7, 0x20, 0x8e, 0x37, 0x23, 0xc4, 0xa7, 0x4a, 0x95, 0xf4, 0xb0, 0xd1, 0xa3, 0x63, 0x70, 0x08,
|
|
0x63, 0x64, 0x11, 0xf6, 0x15, 0xe8, 0xfe, 0xa6, 0xa0, 0x43, 0x29, 0x4a, 0x7a, 0x58, 0xab, 0xd1,
|
|
0x10, 0xec, 0x43, 0x21, 0x58, 0x38, 0x50, 0x94, 0x7b, 0x1b, 0x53, 0x84, 0x60, 0x49, 0x0f, 0x2b,
|
|
0x2d, 0x3a, 0x83, 0x9d, 0xb4, 0xa8, 0xb3, 0xd9, 0xf8, 0x33, 0x29, 0xe6, 0x34, 0xb4, 0xbb, 0x05,
|
|
0x34, 0x94, 0xd2, 0xa4, 0x87, 0x41, 0x31, 0xde, 0x48, 0x04, 0x7a, 0xdd, 0x12, 0x89, 0x10, 0x8c,
|
|
0x87, 0x8e, 0x22, 0x1e, 0x74, 0x22, 0xca, 0xc8, 0xf8, 0x12, 0xab, 0x2c, 0x84, 0x41, 0x5b, 0xe3,
|
|
0x22, 0xe7, 0x22, 0x74, 0x15, 0xf5, 0x51, 0x27, 0xea, 0x49, 0xce, 0xe5, 0x25, 0x04, 0x69, 0x6b,
|
|
0xa0, 0x53, 0xd0, 0xc6, 0x98, 0x53, 0x11, 0x7a, 0x0a, 0xf9, 0xb0, 0x13, 0xf2, 0x9c, 0x4a, 0xa2,
|
|
0x9f, 0x9a, 0xf5, 0x0a, 0x58, 0x92, 0x26, 0xf4, 0xb7, 0x00, 0x8e, 0x48, 0xb3, 0x04, 0x8e, 0x48,
|
|
0x83, 0x5e, 0x81, 0x37, 0xa1, 0xef, 0xc9, 0xbc, 0x10, 0x61, 0xa0, 0x70, 0x0f, 0x36, 0xc5, 0x1d,
|
|
0x69, 0x59, 0xd2, 0xc3, 0x2d, 0x41, 0xc2, 0x8a, 0x5c, 0x50, 0x46, 0x8a, 0x10, 0xba, 0xc1, 0x4e,
|
|
0xb4, 0x4c, 0xc2, 0x0c, 0x61, 0xe8, 0x81, 0xa3, 0xa2, 0x8c, 0x5e, 0xea, 0x2a, 0x44, 0x08, 0xec,
|
|
0x8a, 0x94, 0x54, 0x35, 0x47, 0x80, 0xd5, 0x5a, 0xee, 0x89, 0x45, 0x43, 0x55, 0x9d, 0x07, 0x58,
|
|
0xad, 0xd1, 0x2e, 0xf8, 0x8c, 0x7e, 0x9a, 0xe7, 0x8c, 0x4e, 0x54, 0xe5, 0xfa, 0x78, 0x69, 0x47,
|
|
0x5f, 0xc1, 0x51, 0xc7, 0xb0, 0x16, 0x76, 0x59, 0xd8, 0xff, 0x53, 0x88, 0x8e, 0xc0, 0xad, 0x28,
|
|
0x17, 0x06, 0xd9, 0xa1, 0x19, 0x64, 0x67, 0x63, 0xa3, 0x8d, 0xce, 0x00, 0x56, 0xf5, 0x77, 0x25,
|
|
0x09, 0xfd, 0xb4, 0x20, 0x58, 0x16, 0xdf, 0x5a, 0xe2, 0x6d, 0x08, 0xca, 0xbc, 0x1a, 0xe7, 0x82,
|
|
0x96, 0x5c, 0x61, 0x6d, 0xec, 0x97, 0x79, 0xf5, 0x42, 0xda, 0xca, 0x49, 0x2e, 0x8c, 0x73, 0x60,
|
|
0x9c, 0xe4, 0x42, 0x3b, 0x57, 0x39, 0xdb, 0xff, 0x90, 0xf3, 0x0f, 0x0b, 0xfc, 0xb6, 0x96, 0xff,
|
|
0xcb, 0x00, 0xbf, 0x98, 0xf8, 0x64, 0x3b, 0xac, 0x8b, 0xef, 0x16, 0xb8, 0x05, 0x49, 0x69, 0x21,
|
|
0x83, 0x1b, 0xec, 0x07, 0xd8, 0x58, 0x57, 0x54, 0x12, 0x77, 0xc0, 0x33, 0xc5, 0x8f, 0x6e, 0x82,
|
|
0xa3, 0x1f, 0x49, 0xfd, 0x75, 0x6d, 0x44, 0xdf, 0x2c, 0xf0, 0x4c, 0xaf, 0xa1, 0xe7, 0xe0, 0x35,
|
|
0x2c, 0x2f, 0x09, 0x5b, 0x98, 0x11, 0xd1, 0xed, 0x9b, 0xad, 0x58, 0x72, 0xda, 0xae, 0xef, 0x6f,
|
|
0xc3, 0x31, 0xe2, 0xe8, 0x97, 0x05, 0xae, 0x1e, 0x3e, 0xe8, 0x1d, 0x80, 0x7c, 0x8f, 0xf3, 0x74,
|
|
0x2e, 0x28, 0x0f, 0xad, 0xbd, 0xc1, 0xfe, 0xce, 0xc1, 0xb3, 0x6e, 0x03, 0x4c, 0x0d, 0x0e, 0x0d,
|
|
0x38, 0xae, 0x04, 0x5b, 0xe0, 0x4b, 0xc4, 0xdd, 0x19, 0x5c, 0xff, 0xcb, 0x8d, 0x6e, 0xc0, 0x60,
|
|
0x46, 0x17, 0xe6, 0xb4, 0xe4, 0x12, 0x0d, 0xdb, 0x13, 0xdc, 0x26, 0x2b, 0x2d, 0x7d, 0xda, 0x7f,
|
|
0x62, 0x45, 0x23, 0x70, 0xd4, 0x28, 0x94, 0x77, 0xac, 0x76, 0xdb, 0x8c, 0x3a, 0xde, 0xb1, 0xd6,
|
|
0x0e, 0x83, 0xb7, 0x9e, 0xd9, 0x4f, 0x5d, 0xf5, 0xdf, 0xe0, 0xf1, 0xef, 0x00, 0x00, 0x00, 0xff,
|
|
0xff, 0x18, 0x16, 0x39, 0xa4, 0x2d, 0x08, 0x00, 0x00,
|
|
}
|