package atomic

import (
	"unsafe"
)

// A Value provides an atomic load and store of a consistently typed value.
// The zero value for a Value returns nil from [Value.Load].
// Once [Value.Store] has been called, a Value must not be copied.
//
// A Value must not be copied after first use.
type Value struct {
	v any
}

// efaceWords is interface{} internal representation.

package trace

import "fmt"

// Value is a dynamically-typed value obtained from a trace.
type Value struct {
	kind   ValueKind
	scalar uint64
}

// ValueKind is the type of a dynamically-typed value from a trace.
type ValueKind uint8

const (
	ValueBad ValueKind = iota
	ValueUint64
)

// Kind returns the ValueKind of the value.
//
// It represents the underlying structure of the value.

	KindFloat64Histogram
)

// Value represents a metric value returned by the runtime.
type Value struct {
	kind    ValueKind
	scalar  uint64         // contains scalar values for scalar Kinds.
	pointer unsafe.Pointer // contains non-scalar values.
}

// Kind returns the tag representing the kind of value this is.
func (v Value) Kind() ValueKind {
	return v.kind
}

package main

import "fmt"

type value[T any] struct {
	val T
}

func get[T any](v *value[T]) T {
	return v.val
}

func set[T any](v *value[T], val T) {
	v.val = val
}

func (v *value[T]) set(val T) {
	v.val = val
}

func (v *value[T]) get() T {
	return v.val
}

func main() {
	var v1 value[int]
	set(&v1, 1)
	if got, want := get(&v1), 1; got != want {

      attr {
        key: "dtype"
        value {
          type: DT_FLOAT
        }
      }
      attr {
        key: "value"
        value {
          tensor {
            dtype: DT_FLOAT
            tensor_shape {
            }
            float_val: 7
          }
        }
      }
    }
    ret {
      key: "constant"
      value: "X:output:0"
    }

        value2.explicit

        def value3 = options.getOption(new InternalFlag("prop3", true))
        !value3.get()
        value3.explicit

        def value4 = options.getOption(new InternalFlag("prop4", false))
        value4.get()
        value4.explicit
    }

    def "uses default for boolean option when system property is not set"() {
        expect:

		}, {
			m: labelMap{
				"foo":             "bar",
				"key1":            "value1",
				"key2":            "value2",
				"key3":            "value3",
				"key4WithNewline": "\nvalue4",
			},
			expected: `{"foo":"bar", "key1":"value1", "key2":"value2", "key3":"value3", "key4WithNewline":"\nvalue4"}`,
		},
	} {
		if got := tbl.m.String(); tbl.expected != got {

    def "can add amounts with different units of same quantity"() {
        def sum = Amount.valueOf(valueA, unitsA) + Amount.valueOf(valueB, unitsB)
        expect:
        sum == Amount.valueOf(valueC, unitsC)
        sum.toString() == Amount.valueOf(valueC, unitsC).toString()

        where:
        valueA | unitsA        | valueB | unitsB        | valueC  | unitsC
        0      | Fruit.apples  | 0      | Fruit.oranges | 0       | Fruit.apples

        value << ["value1", "value2"]
    }

    def "accept multiple values"() {
        when:
        checkValidCombinations(combination)

        then:
        noExceptionThrown()

        where:
        combination << [["value2", "value3"], ["value3", "value2"]]
    }

    def "throws exception when single value not found"() {
        when:
        checkValidCombinations(["nonexistent"])

        then:

    @TaskAction
    void doSomething() {
    }

    @Option(option = "valueB", description = "descB")
    public void setValueB(boolean value) {
    }

    @Option(option = "valueA", description = "descA")
    public void setValueA(boolean value) {
    }

    @Option(option = "valueC", description = "descC")
    public void setValueC(boolean value) {
    }