// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// Class structure for #GSocketControlMessage.
type SocketControlMessageClass struct {
	_ structs.HostLayout

	ParentClass gobject.ObjectClass

	xGetSize uintptr

	xGetLevel uintptr

	xGetType uintptr

	xSerialize uintptr

	xDeserialize uintptr

	xGReserved1 uintptr

	xGReserved2 uintptr

	xGReserved3 uintptr

	xGReserved4 uintptr

	xGReserved5 uintptr
}

func (x *SocketControlMessageClass) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// OverrideGetSize sets the "get_size" callback function.
// gets the size of the message.
func (x *SocketControlMessageClass) OverrideGetSize(cb func(*SocketControlMessage) uint) {
	if cb == nil {
		x.xGetSize = 0
	} else {
		x.xGetSize = purego.NewCallback(func(MessageVarp uintptr) uint {
			return cb(SocketControlMessageNewFromInternalPtr(MessageVarp))
		})
	}
}

// GetGetSize gets the "get_size" callback function.
// gets the size of the message.
func (x *SocketControlMessageClass) GetGetSize() func(*SocketControlMessage) uint {
	if x.xGetSize == 0 {
		return nil
	}
	var rawCallback func(MessageVarp uintptr) uint
	purego.RegisterFunc(&rawCallback, x.xGetSize)
	return func(MessageVar *SocketControlMessage) uint {
		return rawCallback(MessageVar.GoPointer())
	}
}

// OverrideGetLevel sets the "get_level" callback function.
// gets the protocol of the message.
func (x *SocketControlMessageClass) OverrideGetLevel(cb func(*SocketControlMessage) int) {
	if cb == nil {
		x.xGetLevel = 0
	} else {
		x.xGetLevel = purego.NewCallback(func(MessageVarp uintptr) int {
			return cb(SocketControlMessageNewFromInternalPtr(MessageVarp))
		})
	}
}

// GetGetLevel gets the "get_level" callback function.
// gets the protocol of the message.
func (x *SocketControlMessageClass) GetGetLevel() func(*SocketControlMessage) int {
	if x.xGetLevel == 0 {
		return nil
	}
	var rawCallback func(MessageVarp uintptr) int
	purego.RegisterFunc(&rawCallback, x.xGetLevel)
	return func(MessageVar *SocketControlMessage) int {
		return rawCallback(MessageVar.GoPointer())
	}
}

// OverrideGetType sets the "get_type" callback function.
// gets the protocol specific type of the message.
func (x *SocketControlMessageClass) OverrideGetType(cb func(*SocketControlMessage) int) {
	if cb == nil {
		x.xGetType = 0
	} else {
		x.xGetType = purego.NewCallback(func(MessageVarp uintptr) int {
			return cb(SocketControlMessageNewFromInternalPtr(MessageVarp))
		})
	}
}

// GetGetType gets the "get_type" callback function.
// gets the protocol specific type of the message.
func (x *SocketControlMessageClass) GetGetType() func(*SocketControlMessage) int {
	if x.xGetType == 0 {
		return nil
	}
	var rawCallback func(MessageVarp uintptr) int
	purego.RegisterFunc(&rawCallback, x.xGetType)
	return func(MessageVar *SocketControlMessage) int {
		return rawCallback(MessageVar.GoPointer())
	}
}

// OverrideSerialize sets the "serialize" callback function.
// Writes out the message data.
func (x *SocketControlMessageClass) OverrideSerialize(cb func(*SocketControlMessage, uintptr)) {
	if cb == nil {
		x.xSerialize = 0
	} else {
		x.xSerialize = purego.NewCallback(func(MessageVarp uintptr, DataVarp uintptr) {
			cb(SocketControlMessageNewFromInternalPtr(MessageVarp), DataVarp)
		})
	}
}

// GetSerialize gets the "serialize" callback function.
// Writes out the message data.
func (x *SocketControlMessageClass) GetSerialize() func(*SocketControlMessage, uintptr) {
	if x.xSerialize == 0 {
		return nil
	}
	var rawCallback func(MessageVarp uintptr, DataVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xSerialize)
	return func(MessageVar *SocketControlMessage, DataVar uintptr) {
		rawCallback(MessageVar.GoPointer(), DataVar)
	}
}

// OverrideDeserialize sets the "deserialize" callback function.
// Tries to deserialize a message.
func (x *SocketControlMessageClass) OverrideDeserialize(cb func(int, int, uint, uintptr) *SocketControlMessage) {
	if cb == nil {
		x.xDeserialize = 0
	} else {
		x.xDeserialize = purego.NewCallback(func(LevelVarp int, TypeVarp int, SizeVarp uint, DataVarp uintptr) uintptr {
			ret := cb(LevelVarp, TypeVarp, SizeVarp, DataVarp)
			if ret == nil {
				return 0
			}
			return ret.GoPointer()
		})
	}
}

// GetDeserialize gets the "deserialize" callback function.
// Tries to deserialize a message.
func (x *SocketControlMessageClass) GetDeserialize() func(int, int, uint, uintptr) *SocketControlMessage {
	if x.xDeserialize == 0 {
		return nil
	}
	var rawCallback func(LevelVarp int, TypeVarp int, SizeVarp uint, DataVarp uintptr) uintptr
	purego.RegisterFunc(&rawCallback, x.xDeserialize)
	return func(LevelVar int, TypeVar int, SizeVar uint, DataVar uintptr) *SocketControlMessage {
		rawRet := rawCallback(LevelVar, TypeVar, SizeVar, DataVar)
		if rawRet == 0 {
			return nil
		}
		ret := &SocketControlMessage{}
		ret.Ptr = rawRet
		return ret
	}
}

// OverrideGReserved1 sets the "_g_reserved1" callback function.
func (x *SocketControlMessageClass) OverrideGReserved1(cb func()) {
	if cb == nil {
		x.xGReserved1 = 0
	} else {
		x.xGReserved1 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved1 gets the "_g_reserved1" callback function.
func (x *SocketControlMessageClass) GetGReserved1() func() {
	if x.xGReserved1 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved1)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved2 sets the "_g_reserved2" callback function.
func (x *SocketControlMessageClass) OverrideGReserved2(cb func()) {
	if cb == nil {
		x.xGReserved2 = 0
	} else {
		x.xGReserved2 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved2 gets the "_g_reserved2" callback function.
func (x *SocketControlMessageClass) GetGReserved2() func() {
	if x.xGReserved2 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved2)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved3 sets the "_g_reserved3" callback function.
func (x *SocketControlMessageClass) OverrideGReserved3(cb func()) {
	if cb == nil {
		x.xGReserved3 = 0
	} else {
		x.xGReserved3 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved3 gets the "_g_reserved3" callback function.
func (x *SocketControlMessageClass) GetGReserved3() func() {
	if x.xGReserved3 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved3)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved4 sets the "_g_reserved4" callback function.
func (x *SocketControlMessageClass) OverrideGReserved4(cb func()) {
	if cb == nil {
		x.xGReserved4 = 0
	} else {
		x.xGReserved4 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved4 gets the "_g_reserved4" callback function.
func (x *SocketControlMessageClass) GetGReserved4() func() {
	if x.xGReserved4 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved4)
	return func() {
		rawCallback()
	}
}

// OverrideGReserved5 sets the "_g_reserved5" callback function.
func (x *SocketControlMessageClass) OverrideGReserved5(cb func()) {
	if cb == nil {
		x.xGReserved5 = 0
	} else {
		x.xGReserved5 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGReserved5 gets the "_g_reserved5" callback function.
func (x *SocketControlMessageClass) GetGReserved5() func() {
	if x.xGReserved5 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGReserved5)
	return func() {
		rawCallback()
	}
}

type SocketControlMessagePrivate struct {
	_ structs.HostLayout
}

func (x *SocketControlMessagePrivate) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// A `GSocketControlMessage` is a special-purpose utility message that
// can be sent to or received from a [class@Gio.Socket]. These types of
// messages are often called ‘ancillary data’.
//
// The message can represent some sort of special instruction to or
// information from the socket or can represent a special kind of
// transfer to the peer (for example, sending a file descriptor over
// a UNIX socket).
//
// These messages are sent with [method@Gio.Socket.send_message] and received
// with [method@Gio.Socket.receive_message].
//
// To extend the set of control message that can be sent, subclass this
// class and override the `get_size`, `get_level`, `get_type` and `serialize`
// methods.
//
// To extend the set of control messages that can be received, subclass
// this class and implement the `deserialize` method. Also, make sure your
// class is registered with the [type@GObject.Type] type system before calling
// [method@Gio.Socket.receive_message] to read such a message.
type SocketControlMessage struct {
	gobject.Object
}

var xSocketControlMessageGLibType func() types.GType

func SocketControlMessageGLibType() types.GType {
	return xSocketControlMessageGLibType()
}

func SocketControlMessageNewFromInternalPtr(ptr uintptr) *SocketControlMessage {
	cls := &SocketControlMessage{}
	cls.Ptr = ptr
	return cls
}

var xSocketControlMessageGetLevel func(uintptr) int

// Returns the "level" (i.e. the originating protocol) of the control message.
// This is often SOL_SOCKET.
func (x *SocketControlMessage) GetLevel() int {

	cret := xSocketControlMessageGetLevel(x.GoPointer())
	return cret
}

var xSocketControlMessageGetMsgType func(uintptr) int

// Returns the protocol specific type of the control message.
// For instance, for UNIX fd passing this would be SCM_RIGHTS.
func (x *SocketControlMessage) GetMsgType() int {

	cret := xSocketControlMessageGetMsgType(x.GoPointer())
	return cret
}

var xSocketControlMessageGetSize func(uintptr) uint

// Returns the space required for the control message, not including
// headers or alignment.
func (x *SocketControlMessage) GetSize() uint {

	cret := xSocketControlMessageGetSize(x.GoPointer())
	return cret
}

var xSocketControlMessageSerialize func(uintptr, uintptr)

// Converts the data in the message to bytes placed in the
// message.
//
// @data is guaranteed to have enough space to fit the size
// returned by g_socket_control_message_get_size() on this
// object.
func (x *SocketControlMessage) Serialize(DataVar uintptr) {

	xSocketControlMessageSerialize(x.GoPointer(), DataVar)

}

func (c *SocketControlMessage) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *SocketControlMessage) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

var xSocketControlMessageDeserialize func(int, int, uint, uintptr) uintptr

// Tries to deserialize a socket control message of a given
// @level and @type. This will ask all known (to GType) subclasses
// of #GSocketControlMessage if they can understand this kind
// of message and if so deserialize it into a #GSocketControlMessage.
//
// If there is no implementation for this kind of control message, %NULL
// will be returned.
func SocketControlMessageDeserialize(LevelVar int, TypeVar int, SizeVar uint, DataVar uintptr) *SocketControlMessage {
	var cls *SocketControlMessage

	cret := xSocketControlMessageDeserialize(LevelVar, TypeVar, SizeVar, DataVar)

	if cret == 0 {
		return nil
	}
	cls = &SocketControlMessage{}
	cls.Ptr = cret
	return cls
}

func init() {
	core.SetPackageName("GIO", "gio-2.0")
	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GIO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xSocketControlMessageGLibType, libs, "g_socket_control_message_get_type")

	core.PuregoSafeRegister(&xSocketControlMessageGetLevel, libs, "g_socket_control_message_get_level")
	core.PuregoSafeRegister(&xSocketControlMessageGetMsgType, libs, "g_socket_control_message_get_msg_type")
	core.PuregoSafeRegister(&xSocketControlMessageGetSize, libs, "g_socket_control_message_get_size")
	core.PuregoSafeRegister(&xSocketControlMessageSerialize, libs, "g_socket_control_message_serialize")

	core.PuregoSafeRegister(&xSocketControlMessageDeserialize, libs, "g_socket_control_message_deserialize")

}