1set/starlet

package atom

import (
    tps "github.com/1set/starlet/dataconv/types"
    "go.starlark.net/starlark"
)

// for integer

var (
    intMethods = map[string]*starlark.Builtin{
        "get": starlark.NewBuiltin("get", intGet),
        "set": starlark.NewBuiltin("set", intSet),
        "cas": starlark.NewBuiltin("cas", intCAS),
        "add": starlark.NewBuiltin("add", intAdd),
        "sub": starlark.NewBuiltin("sub", intSub),
        "inc": starlark.NewBuiltin("inc", intInc),
        "dec": starlark.NewBuiltin("dec", intDec),
    }
)

func intGet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.MakeInt64(recv.val.Load()), nil
}

func intSet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var value int64
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value", &value); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    recv.val.Store(value)
    return starlark.None, nil
}

func intCAS(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var oldVal, newVal int64
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "old", &oldVal, "new", &newVal); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.Bool(recv.val.CAS(oldVal, newVal)), nil
}

func intAdd(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var delta int64
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "delta", &delta); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.MakeInt64(recv.val.Add(delta)), nil
}

func intSub(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var delta int64
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "delta", &delta); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.MakeInt64(recv.val.Sub(delta)), nil
}

func intInc(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.MakeInt64(recv.val.Inc()), nil
}

func intDec(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicInt)
    return starlark.MakeInt64(recv.val.Dec()), nil
}

// for float

var (
    floatMethods = map[string]*starlark.Builtin{
        "get": starlark.NewBuiltin("get", floatGet),
        "set": starlark.NewBuiltin("set", floatSet),
        "cas": starlark.NewBuiltin("cas", floatCAS),
        "add": starlark.NewBuiltin("add", floatAdd),
        "sub": starlark.NewBuiltin("sub", floatSub),
    }
)

func floatGet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicFloat)
    return starlark.Float(recv.val.Load()), nil
}

func floatSet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var value tps.FloatOrInt
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value", &value); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicFloat)
    recv.val.Store(value.GoFloat())
    return starlark.None, nil
}

func floatCAS(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var oldVal, newVal tps.FloatOrInt
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "old", &oldVal, "new", &newVal); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicFloat)
    return starlark.Bool(recv.val.CAS(oldVal.GoFloat(), newVal.GoFloat())), nil
}

func floatAdd(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var delta tps.FloatOrInt
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "delta", &delta); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicFloat)
    return starlark.Float(recv.val.Add(delta.GoFloat())), nil
}

func floatSub(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var delta tps.FloatOrInt
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "delta", &delta); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicFloat)
    return starlark.Float(recv.val.Sub(delta.GoFloat())), nil
}

// for string

var (
    stringMethods = map[string]*starlark.Builtin{
        "get": starlark.NewBuiltin("get", stringGet),
        "set": starlark.NewBuiltin("set", stringSet),
        "cas": starlark.NewBuiltin("cas", stringCAS),
    }
)

func stringGet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    if err := starlark.UnpackPositionalArgs(b.Name(), args, kwargs, 0); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicString)
    return starlark.String(recv.val.Load()), nil
}

func stringSet(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var value string
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value", &value); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicString)
    recv.val.Store(value)
    return starlark.None, nil
}

func stringCAS(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
    var oldVal, newVal string
    if err := starlark.UnpackArgs(b.Name(), args, kwargs, "old", &oldVal, "new", &newVal); err != nil {
        return nil, err
    }
    recv := b.Receiver().(*AtomicString)
    return starlark.Bool(recv.val.CompareAndSwap(oldVal, newVal)), nil
}