// GoCall creates instance of security.Call that uses the provided Java
// Call as its underlying implementation.
func GoCall(env jutil.Env, jCall jutil.Object) (security.Call, error) {
if jCall.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jCall, jCallImplClass) {
// Called with our implementation of Call, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jCall, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.Call)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java call; it will be de-referenced when the go call
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jCall = jutil.NewGlobalRef(env, jCall)
call := &callImpl{
jCall: jCall,
}
runtime.SetFinalizer(call, func(c *callImpl) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, c.jCall)
})
return call, nil
}
// GoPrincipal converts the provided Java VPrincipal object into a Go Principal.
func GoPrincipal(env jutil.Env, jPrincipal jutil.Object) (security.Principal, error) {
if jPrincipal.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jPrincipal, jVPrincipalImplClass) {
// Called with our implementation of VPrincipal, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jPrincipal, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.Principal)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java VPrincipal; it will be de-referenced when the Go Principal
// created below is garbage-collected (through the finalizer callback we
// setup just below).
jPrincipal = jutil.NewGlobalRef(env, jPrincipal)
// Create Go Principal.
p := &principal{
jPrincipal: jPrincipal,
}
runtime.SetFinalizer(p, func(p *principal) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, p.jPrincipal)
})
return p, nil
}
// GoBlessingRoots creates an instance of security.BlessingRoots that uses the
// provided Java BlessingRoots as its underlying implementation.
func GoBlessingRoots(env jutil.Env, jBlessingRoots jutil.Object) (security.BlessingRoots, error) {
if jBlessingRoots.IsNull() {
return nil, nil
}
if jutil.IsInstanceOf(env, jBlessingRoots, jBlessingRootsImplClass) {
// Called with our implementation of BlessingRoots, which maintains a Go reference - use it.
ref, err := jutil.CallLongMethod(env, jBlessingRoots, "nativeRef", nil)
if err != nil {
return nil, err
}
return (*(*security.BlessingRoots)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// Reference Java BlessingRoots; it will be de-referenced when the Go
// BlessingRoots created below is garbage-collected (through the finalizer
// callback we setup just below).
jBlessingRoots = jutil.NewGlobalRef(env, jBlessingRoots)
r := &blessingRoots{
jBlessingRoots: jBlessingRoots,
}
runtime.SetFinalizer(r, func(r *blessingRoots) {
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jutil.DeleteGlobalRef(env, r.jBlessingRoots)
})
return r, nil
}
// GoBlessings converts the provided Java Blessings into Go Blessings.
func GoBlessings(env jutil.Env, jBlessings jutil.Object) (security.Blessings, error) {
if jBlessings.IsNull() {
return security.Blessings{}, nil
}
ref, err := jutil.CallLongMethod(env, jBlessings, "nativeRef", nil)
if err != nil {
return security.Blessings{}, err
}
return (*(*security.Blessings)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// GoBlessingPattern converts the provided Java BlessingPattern into Go BlessingPattern.
func GoBlessingPattern(env jutil.Env, jPattern jutil.Object) (pattern security.BlessingPattern, err error) {
if jPattern.IsNull() {
return "", nil
}
ref, err := jutil.CallLongMethod(env, jPattern, "nativeRef", nil)
if err != nil {
return "", err
}
return (*(*security.BlessingPattern)(jutil.GoRefValue(jutil.Ref(ref)))), nil
}
// GoContext converts the provided Java VContext into a Go context and
// a cancel function (if any) that can be used to cancel the context.
func GoContext(env jutil.Env, jContext jutil.Object) (*context.T, context.CancelFunc, error) {
if jContext.IsNull() {
return nil, nil, nil
}
goCtxRefVal, err := jutil.CallLongMethod(env, jContext, "nativeRef", nil)
if err != nil {
return nil, nil, err
}
goCtxRef := jutil.Ref(goCtxRefVal)
goCancelRefVal, err := jutil.CallLongMethod(env, jContext, "nativeCancelRef", nil)
if err != nil {
return nil, nil, err
}
goCancelRef := jutil.Ref(goCancelRefVal)
var cancel context.CancelFunc
if goCancelRef != jutil.NullRef {
cancel = *(*context.CancelFunc)(jutil.GoRefValue(goCancelRef))
}
return (*context.T)(jutil.GoRefValue(goCtxRef)), cancel, nil
}