pumpkin-api-go/pkg/pumpkin_plugin_context/wit_bindings.go

// Generated by `wit-bindgen` 0.57.1. DO NOT EDIT!
//
// This code was generated from the following packages:
//     pumpkin:plugin@0.1.0

package pumpkin_plugin_context

import (
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_command"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_event"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_permission"
	"github.com/Pumpkin-MC/pumpkin-api-go/pkg/pumpkin_plugin_server"
	witRuntime "go.bytecodealliance.org/pkg/wit/runtime"
	witTypes "go.bytecodealliance.org/pkg/wit/types"
	"runtime"
	"unsafe"
)

type Server = pumpkin_plugin_server.Server
type EventType = pumpkin_plugin_event.EventType
type EventPriority = pumpkin_plugin_event.EventPriority
type Command = pumpkin_plugin_command.Command
type Permission = pumpkin_plugin_permission.Permission

//go:wasmimport pumpkin:plugin/context@0.1.0 [resource-drop]context
func resourceDropContext(handle int32)

// A contextual handle for plugin-related operations.
type Context struct {
	handle *witRuntime.Handle
}

func (self *Context) TakeHandle() int32 {
	return self.handle.Take()
}

func (self *Context) SetHandle(handle int32) {
	self.handle.Set(handle)
}

func (self *Context) Handle() int32 {
	return self.handle.Use()
}

func (self *Context) Drop() {
	handle := self.handle.TakeOrNil()
	if handle != 0 {
		resourceDropContext(handle)
	}
}

func ContextFromOwnHandle(handleValue int32) *Context {
	handle := witRuntime.MakeHandle(handleValue)
	value := &Context{handle}
	runtime.AddCleanup(value, func(_ int) {
		handleValue := handle.TakeOrNil()
		if handleValue != 0 {
			resourceDropContext(handleValue)
		}
	}, 0)
	return value
}

func ContextFromBorrowHandle(handleValue int32) *Context {
	handle := witRuntime.MakeHandle(handleValue)
	return &Context{handle}
}

//go:wasmimport pumpkin:plugin/context@0.1.0 [method]context.register-event
func wasm_import_method_context_register_event(arg0 int32, arg1 int32, arg2 int32, arg3 int32, arg4 int32)

func (self *Context) RegisterEvent(handlerId uint32, eventType pumpkin_plugin_event.EventType, eventPriority pumpkin_plugin_event.EventPriority, blocking bool) {

	var result int32
	if blocking {
		result = 1
	} else {
		result = 0
	}
	wasm_import_method_context_register_event((self).Handle(), int32(handlerId), int32(eventType), int32(eventPriority), result)

}

//go:wasmimport pumpkin:plugin/context@0.1.0 [method]context.register-command
func wasm_import_method_context_register_command(arg0 int32, arg1 int32, arg2 uintptr, arg3 uint32)

func (self *Context) RegisterCommand(command *pumpkin_plugin_command.Command, permission string) {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	utf8 := unsafe.Pointer(unsafe.StringData(permission))
	pinner.Pin(utf8)
	wasm_import_method_context_register_command((self).Handle(), (command).TakeHandle(), uintptr(utf8), uint32(len(permission)))

}

//go:wasmimport pumpkin:plugin/context@0.1.0 [method]context.register-permission
func wasm_import_method_context_register_permission(arg0 int32, arg1 uintptr, arg2 uint32, arg3 uintptr, arg4 uint32, arg5 int32, arg6 int32, arg7 uintptr, arg8 uint32, arg9 uintptr)

func (self *Context) RegisterPermission(permission pumpkin_plugin_permission.Permission) witTypes.Result[witTypes.Unit, string] {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (3 * 4), 4))
	utf8 := unsafe.Pointer(unsafe.StringData((permission).Node))
	pinner.Pin(utf8)
	utf80 := unsafe.Pointer(unsafe.StringData((permission).Description))
	pinner.Pin(utf80)
	var variant int32
	var variant1 int32
	switch (permission).Default.Tag() {
	case pumpkin_plugin_permission.PermissionDefaultDeny:

		variant = int32(0)
		variant1 = 0

	case pumpkin_plugin_permission.PermissionDefaultAllow:

		variant = int32(1)
		variant1 = 0

	case pumpkin_plugin_permission.PermissionDefaultOp:
		payload := (permission).Default.Op()

		variant = int32(2)
		variant1 = int32(payload)

	default:
		panic("unreachable")
	}
	slice := (permission).Children
	length := uint32(len(slice))
	result3 := witRuntime.Allocate(pinner, uintptr(length*(3*4)), 4)
	for index, element := range slice {
		base := unsafe.Add(result3, index*(3*4))
		utf82 := unsafe.Pointer(unsafe.StringData((element).Node))
		pinner.Pin(utf82)
		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 4)) = uint32(uint32(len((element).Node)))
		*(*uint32)(unsafe.Add(unsafe.Pointer(base), 0)) = uint32(uintptr(uintptr(utf82)))
		var result int32
		if (element).Value {
			result = 1
		} else {
			result = 0
		}
		*(*int8)(unsafe.Add(unsafe.Pointer(base), (2 * 4))) = int8(result)

	}

	wasm_import_method_context_register_permission((self).Handle(), uintptr(utf8), uint32(len((permission).Node)), uintptr(utf80), uint32(len((permission).Description)), variant, variant1, uintptr(result3), length, returnArea)
	var result4 witTypes.Result[witTypes.Unit, string]
	switch uint8(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))) {
	case 0:

		result4 = witTypes.Ok[witTypes.Unit, string](witTypes.Unit{})
	case 1:
		value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), (2 * 4))))

		result4 = witTypes.Err[witTypes.Unit, string](value)
	default:
		panic("unreachable")
	}
	result5 := result4
	return result5

}

//go:wasmimport pumpkin:plugin/context@0.1.0 [method]context.get-data-folder
func wasm_import_method_context_get_data_folder(arg0 int32, arg1 uintptr)

func (self *Context) GetDataFolder() string {
	pinner := &runtime.Pinner{}
	defer pinner.Unpin()

	returnArea := uintptr(witRuntime.Allocate(pinner, (2 * 4), 4))
	wasm_import_method_context_get_data_folder((self).Handle(), returnArea)
	value := unsafe.String((*uint8)(unsafe.Pointer(uintptr(*(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 0))))), *(*uint32)(unsafe.Add(unsafe.Pointer(returnArea), 4)))
	result := value
	return result

}

//go:wasmimport pumpkin:plugin/context@0.1.0 [method]context.get-server
func wasm_import_method_context_get_server(arg0 int32) int32

func (self *Context) GetServer() *pumpkin_plugin_server.Server {

	result := wasm_import_method_context_get_server((self).Handle())
	return pumpkin_plugin_server.ServerFromOwnHandle(int32(uintptr(result)))

}