All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.purejava.appindicator._GMountOperationClass Maven / Gradle / Ivy

There is a newer version: 1.4.2
Show newest version
// Generated by jextract

package org.purejava.appindicator;

import java.lang.foreign.Arena;
import java.lang.foreign.MemoryLayout;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SegmentAllocator;
import java.lang.invoke.VarHandle;
/**
 * {@snippet :
 * struct _GMountOperationClass {
 *     struct _GObjectClass parent_class;
 *     void (*ask_password)(struct _GMountOperation*,char*,char*,char*,enum GAskPasswordFlags);
 *     void (*ask_question)(struct _GMountOperation*,char*,char**);
 *     void (*reply)(struct _GMountOperation*,enum GMountOperationResult);
 *     void (*aborted)(struct _GMountOperation*);
 *     void (*show_processes)(struct _GMountOperation*,char*,struct _GArray*,char**);
 *     void (*show_unmount_progress)(struct _GMountOperation*,char*,long,long);
 *     void (*_g_reserved1)();
 *     void (*_g_reserved2)();
 *     void (*_g_reserved3)();
 *     void (*_g_reserved4)();
 *     void (*_g_reserved5)();
 *     void (*_g_reserved6)();
 *     void (*_g_reserved7)();
 *     void (*_g_reserved8)();
 *     void (*_g_reserved9)();
 * };
 * }
 */
public class _GMountOperationClass {

    public static MemoryLayout $LAYOUT() {
        return constants$1174.const$2;
    }
    public static MemorySegment parent_class$slice(MemorySegment seg) {
        return seg.asSlice(0, 136);
    }
    /**
     * {@snippet :
 * void (*ask_password)(struct _GMountOperation*,char*,char*,char*,enum GAskPasswordFlags);
     * }
     */
    public interface ask_password {

        void apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, java.lang.foreign.MemorySegment _x2, java.lang.foreign.MemorySegment _x3, int _x4);
        static MemorySegment allocate(ask_password fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1174.const$3, fi, constants$646.const$4, scope);
        }
        static ask_password ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, java.lang.foreign.MemorySegment __x2, java.lang.foreign.MemorySegment __x3, int __x4) -> {
                try {
                    constants$1174.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3, __x4);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle ask_password$VH() {
        return constants$1174.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*ask_password)(struct _GMountOperation*,char*,char*,char*,enum GAskPasswordFlags);
     * }
     */
    public static MemorySegment ask_password$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1174.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*ask_password)(struct _GMountOperation*,char*,char*,char*,enum GAskPasswordFlags);
     * }
     */
    public static void ask_password$set(MemorySegment seg, MemorySegment x) {
        constants$1174.const$5.set(seg, x);
    }
    public static MemorySegment ask_password$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1174.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void ask_password$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1174.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static ask_password ask_password(MemorySegment segment, Arena scope) {
        return ask_password.ofAddress(ask_password$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*ask_question)(struct _GMountOperation*,char*,char**);
     * }
     */
    public interface ask_question {

        void apply(java.lang.foreign.MemorySegment key, java.lang.foreign.MemorySegment value, java.lang.foreign.MemorySegment user_data);
        static MemorySegment allocate(ask_question fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1175.const$0, fi, constants$14.const$3, scope);
        }
        static ask_question ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _key, java.lang.foreign.MemorySegment _value, java.lang.foreign.MemorySegment _user_data) -> {
                try {
                    constants$14.const$5.invokeExact(symbol, _key, _value, _user_data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle ask_question$VH() {
        return constants$1175.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*ask_question)(struct _GMountOperation*,char*,char**);
     * }
     */
    public static MemorySegment ask_question$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*ask_question)(struct _GMountOperation*,char*,char**);
     * }
     */
    public static void ask_question$set(MemorySegment seg, MemorySegment x) {
        constants$1175.const$1.set(seg, x);
    }
    public static MemorySegment ask_question$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void ask_question$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1175.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static ask_question ask_question(MemorySegment segment, Arena scope) {
        return ask_question.ofAddress(ask_question$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*reply)(struct _GMountOperation*,enum GMountOperationResult);
     * }
     */
    public interface reply {

        void apply(java.lang.foreign.MemorySegment _x0, int _x1);
        static MemorySegment allocate(reply fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1175.const$2, fi, constants$40.const$2, scope);
        }
        static reply ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, int __x1) -> {
                try {
                    constants$509.const$5.invokeExact(symbol, __x0, __x1);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle reply$VH() {
        return constants$1175.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*reply)(struct _GMountOperation*,enum GMountOperationResult);
     * }
     */
    public static MemorySegment reply$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*reply)(struct _GMountOperation*,enum GMountOperationResult);
     * }
     */
    public static void reply$set(MemorySegment seg, MemorySegment x) {
        constants$1175.const$3.set(seg, x);
    }
    public static MemorySegment reply$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void reply$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1175.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static reply reply(MemorySegment segment, Arena scope) {
        return reply.ofAddress(reply$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*aborted)(struct _GMountOperation*);
     * }
     */
    public interface aborted {

        void apply(java.lang.foreign.MemorySegment display);
        static MemorySegment allocate(aborted fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1175.const$4, fi, constants$13.const$1, scope);
        }
        static aborted ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _display) -> {
                try {
                    constants$13.const$3.invokeExact(symbol, _display);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle aborted$VH() {
        return constants$1175.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*aborted)(struct _GMountOperation*);
     * }
     */
    public static MemorySegment aborted$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*aborted)(struct _GMountOperation*);
     * }
     */
    public static void aborted$set(MemorySegment seg, MemorySegment x) {
        constants$1175.const$5.set(seg, x);
    }
    public static MemorySegment aborted$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1175.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void aborted$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1175.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static aborted aborted(MemorySegment segment, Arena scope) {
        return aborted.ofAddress(aborted$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*show_processes)(struct _GMountOperation*,char*,struct _GArray*,char**);
     * }
     */
    public interface show_processes {

        void apply(java.lang.foreign.MemorySegment model, java.lang.foreign.MemorySegment path, java.lang.foreign.MemorySegment iter, java.lang.foreign.MemorySegment data);
        static MemorySegment allocate(show_processes fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1176.const$0, fi, constants$42.const$1, scope);
        }
        static show_processes ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment _model, java.lang.foreign.MemorySegment _path, java.lang.foreign.MemorySegment _iter, java.lang.foreign.MemorySegment _data) -> {
                try {
                    constants$259.const$4.invokeExact(symbol, _model, _path, _iter, _data);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle show_processes$VH() {
        return constants$1176.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*show_processes)(struct _GMountOperation*,char*,struct _GArray*,char**);
     * }
     */
    public static MemorySegment show_processes$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1176.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*show_processes)(struct _GMountOperation*,char*,struct _GArray*,char**);
     * }
     */
    public static void show_processes$set(MemorySegment seg, MemorySegment x) {
        constants$1176.const$1.set(seg, x);
    }
    public static MemorySegment show_processes$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1176.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void show_processes$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1176.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static show_processes show_processes(MemorySegment segment, Arena scope) {
        return show_processes.ofAddress(show_processes$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*show_unmount_progress)(struct _GMountOperation*,char*,long,long);
     * }
     */
    public interface show_unmount_progress {

        void apply(java.lang.foreign.MemorySegment _x0, java.lang.foreign.MemorySegment _x1, long _x2, long _x3);
        static MemorySegment allocate(show_unmount_progress fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1176.const$3, fi, constants$1176.const$2, scope);
        }
        static show_unmount_progress ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return (java.lang.foreign.MemorySegment __x0, java.lang.foreign.MemorySegment __x1, long __x2, long __x3) -> {
                try {
                    constants$1176.const$4.invokeExact(symbol, __x0, __x1, __x2, __x3);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle show_unmount_progress$VH() {
        return constants$1176.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*show_unmount_progress)(struct _GMountOperation*,char*,long,long);
     * }
     */
    public static MemorySegment show_unmount_progress$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1176.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*show_unmount_progress)(struct _GMountOperation*,char*,long,long);
     * }
     */
    public static void show_unmount_progress$set(MemorySegment seg, MemorySegment x) {
        constants$1176.const$5.set(seg, x);
    }
    public static MemorySegment show_unmount_progress$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1176.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void show_unmount_progress$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1176.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static show_unmount_progress show_unmount_progress(MemorySegment segment, Arena scope) {
        return show_unmount_progress.ofAddress(show_unmount_progress$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved1)();
     * }
     */
    public interface _g_reserved1 {

        void apply();
        static MemorySegment allocate(_g_reserved1 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1177.const$0, fi, constants$7.const$5, scope);
        }
        static _g_reserved1 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved1$VH() {
        return constants$1177.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved1)();
     * }
     */
    public static MemorySegment _g_reserved1$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved1)();
     * }
     */
    public static void _g_reserved1$set(MemorySegment seg, MemorySegment x) {
        constants$1177.const$1.set(seg, x);
    }
    public static MemorySegment _g_reserved1$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved1$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1177.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved1 _g_reserved1(MemorySegment segment, Arena scope) {
        return _g_reserved1.ofAddress(_g_reserved1$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved2)();
     * }
     */
    public interface _g_reserved2 {

        void apply();
        static MemorySegment allocate(_g_reserved2 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1177.const$2, fi, constants$7.const$5, scope);
        }
        static _g_reserved2 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved2$VH() {
        return constants$1177.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved2)();
     * }
     */
    public static MemorySegment _g_reserved2$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved2)();
     * }
     */
    public static void _g_reserved2$set(MemorySegment seg, MemorySegment x) {
        constants$1177.const$3.set(seg, x);
    }
    public static MemorySegment _g_reserved2$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved2$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1177.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved2 _g_reserved2(MemorySegment segment, Arena scope) {
        return _g_reserved2.ofAddress(_g_reserved2$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved3)();
     * }
     */
    public interface _g_reserved3 {

        void apply();
        static MemorySegment allocate(_g_reserved3 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1177.const$4, fi, constants$7.const$5, scope);
        }
        static _g_reserved3 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved3$VH() {
        return constants$1177.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved3)();
     * }
     */
    public static MemorySegment _g_reserved3$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved3)();
     * }
     */
    public static void _g_reserved3$set(MemorySegment seg, MemorySegment x) {
        constants$1177.const$5.set(seg, x);
    }
    public static MemorySegment _g_reserved3$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1177.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved3$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1177.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved3 _g_reserved3(MemorySegment segment, Arena scope) {
        return _g_reserved3.ofAddress(_g_reserved3$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved4)();
     * }
     */
    public interface _g_reserved4 {

        void apply();
        static MemorySegment allocate(_g_reserved4 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1178.const$0, fi, constants$7.const$5, scope);
        }
        static _g_reserved4 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved4$VH() {
        return constants$1178.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved4)();
     * }
     */
    public static MemorySegment _g_reserved4$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved4)();
     * }
     */
    public static void _g_reserved4$set(MemorySegment seg, MemorySegment x) {
        constants$1178.const$1.set(seg, x);
    }
    public static MemorySegment _g_reserved4$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved4$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1178.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved4 _g_reserved4(MemorySegment segment, Arena scope) {
        return _g_reserved4.ofAddress(_g_reserved4$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved5)();
     * }
     */
    public interface _g_reserved5 {

        void apply();
        static MemorySegment allocate(_g_reserved5 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1178.const$2, fi, constants$7.const$5, scope);
        }
        static _g_reserved5 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved5$VH() {
        return constants$1178.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved5)();
     * }
     */
    public static MemorySegment _g_reserved5$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved5)();
     * }
     */
    public static void _g_reserved5$set(MemorySegment seg, MemorySegment x) {
        constants$1178.const$3.set(seg, x);
    }
    public static MemorySegment _g_reserved5$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved5$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1178.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved5 _g_reserved5(MemorySegment segment, Arena scope) {
        return _g_reserved5.ofAddress(_g_reserved5$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved6)();
     * }
     */
    public interface _g_reserved6 {

        void apply();
        static MemorySegment allocate(_g_reserved6 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1178.const$4, fi, constants$7.const$5, scope);
        }
        static _g_reserved6 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved6$VH() {
        return constants$1178.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved6)();
     * }
     */
    public static MemorySegment _g_reserved6$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved6)();
     * }
     */
    public static void _g_reserved6$set(MemorySegment seg, MemorySegment x) {
        constants$1178.const$5.set(seg, x);
    }
    public static MemorySegment _g_reserved6$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1178.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved6$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1178.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved6 _g_reserved6(MemorySegment segment, Arena scope) {
        return _g_reserved6.ofAddress(_g_reserved6$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved7)();
     * }
     */
    public interface _g_reserved7 {

        void apply();
        static MemorySegment allocate(_g_reserved7 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1179.const$0, fi, constants$7.const$5, scope);
        }
        static _g_reserved7 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved7$VH() {
        return constants$1179.const$1;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved7)();
     * }
     */
    public static MemorySegment _g_reserved7$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$1.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved7)();
     * }
     */
    public static void _g_reserved7$set(MemorySegment seg, MemorySegment x) {
        constants$1179.const$1.set(seg, x);
    }
    public static MemorySegment _g_reserved7$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$1.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved7$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1179.const$1.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved7 _g_reserved7(MemorySegment segment, Arena scope) {
        return _g_reserved7.ofAddress(_g_reserved7$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved8)();
     * }
     */
    public interface _g_reserved8 {

        void apply();
        static MemorySegment allocate(_g_reserved8 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1179.const$2, fi, constants$7.const$5, scope);
        }
        static _g_reserved8 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved8$VH() {
        return constants$1179.const$3;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved8)();
     * }
     */
    public static MemorySegment _g_reserved8$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$3.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved8)();
     * }
     */
    public static void _g_reserved8$set(MemorySegment seg, MemorySegment x) {
        constants$1179.const$3.set(seg, x);
    }
    public static MemorySegment _g_reserved8$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$3.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved8$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1179.const$3.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved8 _g_reserved8(MemorySegment segment, Arena scope) {
        return _g_reserved8.ofAddress(_g_reserved8$get(segment), scope);
    }
    /**
     * {@snippet :
 * void (*_g_reserved9)();
     * }
     */
    public interface _g_reserved9 {

        void apply();
        static MemorySegment allocate(_g_reserved9 fi, Arena scope) {
            return RuntimeHelper.upcallStub(constants$1179.const$4, fi, constants$7.const$5, scope);
        }
        static _g_reserved9 ofAddress(MemorySegment addr, Arena arena) {
            MemorySegment symbol = addr.reinterpret(arena, null);
            return () -> {
                try {
                    constants$64.const$1.invokeExact(symbol);
                } catch (Throwable ex$) {
                    throw new AssertionError("should not reach here", ex$);
                }
            };
        }
    }

    public static VarHandle _g_reserved9$VH() {
        return constants$1179.const$5;
    }
    /**
     * Getter for field:
     * {@snippet :
     * void (*_g_reserved9)();
     * }
     */
    public static MemorySegment _g_reserved9$get(MemorySegment seg) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$5.get(seg);
    }
    /**
     * Setter for field:
     * {@snippet :
     * void (*_g_reserved9)();
     * }
     */
    public static void _g_reserved9$set(MemorySegment seg, MemorySegment x) {
        constants$1179.const$5.set(seg, x);
    }
    public static MemorySegment _g_reserved9$get(MemorySegment seg, long index) {
        return (java.lang.foreign.MemorySegment)constants$1179.const$5.get(seg.asSlice(index*sizeof()));
    }
    public static void _g_reserved9$set(MemorySegment seg, long index, MemorySegment x) {
        constants$1179.const$5.set(seg.asSlice(index*sizeof()), x);
    }
    public static _g_reserved9 _g_reserved9(MemorySegment segment, Arena scope) {
        return _g_reserved9.ofAddress(_g_reserved9$get(segment), scope);
    }
    public static long sizeof() { return $LAYOUT().byteSize(); }
    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
    public static MemorySegment allocateArray(long len, SegmentAllocator allocator) {
        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
    }
    public static MemorySegment ofAddress(MemorySegment addr, Arena scope) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, scope); }
}






© 2015 - 2025 Weber Informatics LLC | Privacy Policy