opentofu/internal/addrs/self.go

package addrs

// Self is the address of the special object "self" that behaves as an alias
// for a containing object currently in scope.
const Self selfT = 0

type selfT int

func (s selfT) referenceableSigil() {
}

func (s selfT) String() string {
	return "self"
}

func (s selfT) UniqueKey() UniqueKey {
	return Self // Self is its own UniqueKey
}

func (s selfT) uniqueKeySigil() {}
addrs: new package for representing addresses This package is intended to contain all the functionality for parsing, representing, and formatting addresses of objects within Terraform. It will eventually subsume the responsibilities of both the InterpolatedVariable and ResourceAddress types in the "terraform" package, but for the moment is just a set of types for representing these things, lacking any way to parse or format them. The remaining functionality will follow in subsequent commits. 2018-03-30 21:58:57 -05:00			`package addrs`

			`// Self is the address of the special object "self" that behaves as an alias`
			`// for a containing object currently in scope.`
			`const Self selfT = 0`

			`type selfT int`

			`func (s selfT) referenceableSigil() {`
			`}`
addrs: All Referenceable implementations support String() This gives us a convenient way to convert back to a string representation that matches what the user would've written in configuration. 2018-04-03 20:03:47 -05:00
			`func (s selfT) String() string {`
			`return "self"`
			`}`
addrs: UniqueKey and UniqueKeyer Many times now we've seen situations where we need to use addresses as map keys, but not all of our address types are comparable and thus we tend to end up using string representations as keys instead. That's problematic because conversion to string uses type information and some of the address types have string representations that are ambiguous with one another. UniqueKey therefore represents an opaque key that is unique for each functionally-distinct address across all types that implement UniqueKeyer. For this initial commit I've implemented UniqueKeyer only for the Referenceable family of types. These are an easy case because they were all already comparable (intentionally) anyway. Later commits can implement UniqueKeyer for other types that are not naturally comparable, such as any which include a ModuleInstance. This also includes a new type addrs.Set which wraps a map as a set of addresses, using the unique keys to ensure that there can be only one element for each distinct address. 2021-07-10 17:18:19 -05:00
			`func (s selfT) UniqueKey() UniqueKey {`
			`return Self // Self is its own UniqueKey`
			`}`

			`func (s selfT) uniqueKeySigil() {}`