package main import ( "github.com/yuin/gopher-lua" "math/big" ) type Balance struct { Security *Security Amount *big.Rat } const luaBalanceTypeName = "balance" // Registers my balance type to given L. func luaRegisterBalances(L *lua.LState) { mt := L.NewTypeMetatable(luaBalanceTypeName) L.SetGlobal("balance", mt) L.SetField(mt, "__index", L.NewFunction(luaBalance__index)) L.SetField(mt, "__tostring", L.NewFunction(luaBalance__tostring)) L.SetField(mt, "__eq", L.NewFunction(luaBalance__eq)) L.SetField(mt, "__lt", L.NewFunction(luaBalance__lt)) L.SetField(mt, "__le", L.NewFunction(luaBalance__le)) L.SetField(mt, "__add", L.NewFunction(luaBalance__add)) L.SetField(mt, "__sub", L.NewFunction(luaBalance__sub)) L.SetField(mt, "__mul", L.NewFunction(luaBalance__mul)) L.SetField(mt, "__div", L.NewFunction(luaBalance__div)) L.SetField(mt, "__unm", L.NewFunction(luaBalance__unm)) L.SetField(mt, "__metatable", lua.LString("protected")) } func BalanceToLua(L *lua.LState, balance *Balance) *lua.LUserData { ud := L.NewUserData() ud.Value = balance L.SetMetatable(ud, L.GetTypeMetatable(luaBalanceTypeName)) return ud } // Checks whether the first lua argument is a *LUserData with *Balance and returns this *Balance. func luaCheckBalance(L *lua.LState, n int) *Balance { ud := L.CheckUserData(n) if balance, ok := ud.Value.(*Balance); ok { return balance } L.ArgError(n, "balance expected") return nil } func luaWeakCheckBalance(L *lua.LState, n int) *Balance { v := L.Get(n) if ud, ok := v.(*lua.LUserData); ok { if balance, ok := ud.Value.(*Balance); ok { return balance } L.ArgError(n, "balance expected") } return nil } func luaGetBalanceOperands(L *lua.LState, n int, m int) (*Balance, *Balance) { bn := luaWeakCheckBalance(L, n) bm := luaWeakCheckBalance(L, m) if bn != nil && bm != nil { return bn, bm } else if bn != nil { nm := L.CheckNumber(m) var balance Balance var rat big.Rat balance.Security = bn.Security balance.Amount = rat.SetFloat64(float64(nm)) if balance.Amount == nil { L.ArgError(n, "non-finite float invalid for operand to balance arithemetic") return nil, nil } return bn, &balance } else if bm != nil { nn := L.CheckNumber(n) var balance Balance var rat big.Rat balance.Security = bm.Security balance.Amount = rat.SetFloat64(float64(nn)) if balance.Amount == nil { L.ArgError(n, "non-finite float invalid for operand to balance arithemetic") return nil, nil } return bm, &balance } L.ArgError(n, "balance expected") return nil, nil } func luaBalance__index(L *lua.LState) int { a := luaCheckBalance(L, 1) field := L.CheckString(2) switch field { case "Security", "security": L.Push(SecurityToLua(L, a.Security)) case "Amount", "amount": float, _ := a.Amount.Float64() L.Push(lua.LNumber(float)) default: L.ArgError(2, "unexpected balance attribute: "+field) } return 1 } func luaBalance__tostring(L *lua.LState) int { b := luaCheckBalance(L, 1) L.Push(lua.LString(b.Security.Symbol + " " + b.Amount.FloatString(b.Security.Precision))) return 1 } func luaBalance__eq(L *lua.LState) int { a := luaCheckBalance(L, 1) b := luaCheckBalance(L, 2) L.Push(lua.LBool(a.Security.SecurityId == b.Security.SecurityId && a.Amount.Cmp(b.Amount) == 0)) return 1 } func luaBalance__lt(L *lua.LState) int { a := luaCheckBalance(L, 1) b := luaCheckBalance(L, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't compare balances with different securities") } L.Push(lua.LBool(a.Amount.Cmp(b.Amount) < 0)) return 1 } func luaBalance__le(L *lua.LState) int { a := luaCheckBalance(L, 1) b := luaCheckBalance(L, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't compare balances with different securities") } L.Push(lua.LBool(a.Amount.Cmp(b.Amount) <= 0)) return 1 } func luaBalance__add(L *lua.LState) int { a, b := luaGetBalanceOperands(L, 1, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't add balances with different securities") } var balance Balance var rat big.Rat balance.Security = a.Security balance.Amount = rat.Add(a.Amount, b.Amount) L.Push(BalanceToLua(L, &balance)) return 1 } func luaBalance__sub(L *lua.LState) int { a, b := luaGetBalanceOperands(L, 1, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't subtract balances with different securities") } var balance Balance var rat big.Rat balance.Security = a.Security balance.Amount = rat.Sub(a.Amount, b.Amount) L.Push(BalanceToLua(L, &balance)) return 1 } func luaBalance__mul(L *lua.LState) int { a, b := luaGetBalanceOperands(L, 1, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't multiply balances with different securities") } var balance Balance var rat big.Rat balance.Security = a.Security balance.Amount = rat.Mul(a.Amount, b.Amount) L.Push(BalanceToLua(L, &balance)) return 1 } func luaBalance__div(L *lua.LState) int { a, b := luaGetBalanceOperands(L, 1, 2) if a.Security.SecurityId != b.Security.SecurityId { L.ArgError(2, "Can't divide balances with different securities") } var balance Balance var rat big.Rat balance.Security = a.Security balance.Amount = rat.Quo(a.Amount, b.Amount) L.Push(BalanceToLua(L, &balance)) return 1 } func luaBalance__unm(L *lua.LState) int { b := luaCheckBalance(L, 1) var balance Balance var rat big.Rat balance.Security = b.Security balance.Amount = rat.Neg(b.Amount) L.Push(BalanceToLua(L, &balance)) return 1 }