jna：如何在结构中指定可变长度(0+)数组？

c8ib6hqw  于 2021-06-30  发布在  Java
关注(0)|答案(1)|浏览(563)

示例结构，其中 count 数组中的字节数，可以是0。我想在java中分配新的示例，并读取本机分配的示例。

public class VarArray extends Structure {
        public byte dummy0;
        public short dummy1;
        public int count;
        public byte[] array;
    }

使用 array = new byte[0] 不允许进入 Structure .
宣布违约 array = new byte[1] 如果计数为0，将从未分配的地址读取。
卸下 array 字段可以读取，因为我可以从指针偏移量访问字节 Structure.size() . 但是，对于分配新示例，我需要手动确定字段大小和对齐填充，以便分配正确的内存大小。
我有两种解决方案-一种没有 array 对于本机分配和0计数的java分配示例，以及具有 array 对于java分配的1+count示例。这似乎有点臃肿，特别是与所需的锅炉板代码。
有更好的办法吗？
或者一种简单的方法来计算字段大小和对齐方式，这样一种类型就足够了？

import java.util.Arrays;
import java.util.List;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;

public class JnaStructTester {

    /**
     * For native-allocated, and 0-count JNA-allocated instances.
     */
    public static class VarArray extends Structure {
        public byte dummy0;
        public short dummy1;
        public int count;

        public VarArray() {}

        public VarArray(Pointer p) {
            super(p);
        }

        public byte[] getArray() {
            byte[] array = new byte[count];
            if (count > 0) {
                int offset = size();
                getPointer().read(offset, array, 0, count);
            }
            return array;
        }

        @Override
        protected List<String> getFieldOrder() {
            return List.of("dummy0", "dummy1", "count");
        }
    }

    /**
     * For 1+ count JNA-allocated instances.
     */
    public static class VarArrayX extends VarArray {
        public byte[] array;

        public VarArrayX() {}

        @Override
        public byte[] getArray() {
            return array;
        }

        @Override
        protected List<String> getFieldOrder() {
            return List.of("dummy0", "dummy1", "count", "array");
        }
    }

    public static void main(String[] args) {
        var va0 = new VarArrayX();
        va0.dummy0 = (byte) 0xef;
        va0.dummy1 = (short) 0xabcd;
        va0.count = 7;
        va0.array = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
        va0.write();

        var va1 = new VarArray();
        va1.dummy0 = (byte) 0xab;
        va1.dummy1 = (short) 0xcdef;
        va1.write();

        print(new Pointer(Pointer.nativeValue(va0.getPointer())));
        print(new Pointer(Pointer.nativeValue(va1.getPointer())));
    }

    private static void print(Pointer p) {
        var va = new VarArray(p);
        va.read();
        System.out.println(va);
        System.out.println("byte[] array=" + Arrays.toString(va.getArray()));
        System.out.println();
    }
}

输出：

JnaStructTester$VarArray(native@0x7fb6835524b0) (8 bytes) {
  byte dummy0@0=ffffffef
  short dummy1@2=ffffabcd
  int count@4=7
}
byte[] array=[1, 2, 3, 4, 5, 6, 7]

JnaStructTester$VarArray(native@0x7fb683551210) (8 bytes) {
  byte dummy0@0=ffffffab
  short dummy1@2=ffffcdef
  int count@4=0
}
byte[] array=[]

（我使用的是相当旧的jna版本4.2.2）

更新（2020-01-07）

感谢daniel widdis的建议，这里有一个很好的解决方案。
无法根据数组是否为空动态修改字段列表。当不包括variable array字段时，布局是静态缓存的，因此具有非空数组的未来示例将失败。取而代之的是：
阵列调整为 ensureAllocated() ，以避免空数组错误。 writeField() 仅当数组非空时写入字段。 readField() 根据已读取的计数设置数组大小，如果计数为0，则跳过读取数组。
通过将数组设置为 readField() ，则自动填充完整数组，无需手动创建。

import java.util.Arrays;
import java.util.List;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;

public class JnaStructTester {

    public static class VarArray extends Structure {
        public short dummy0;
        public int dummy1;
        public byte count;
        public byte[] array = new byte[0];

        public VarArray() {}

        public VarArray(byte[] array) {
            this.count = (byte) array.length;
            this.array = array;
        }

        public VarArray(Pointer p) {
            super(p);
        }

        @Override
        protected void ensureAllocated() {
            if (count == 0) array = new byte[1];
            super.ensureAllocated();
            if (count == 0) array = new byte[0];
        }

        @Override
        protected void writeField(StructField structField) {
            if (structField.name.equals("array") && count == 0) return;
            super.writeField(structField);
        }

        @Override
        protected Object readField(StructField structField) {
            if (structField.name.equals("array")) {
                array = new byte[count];
                if (count == 0) return null;
            }
            return super.readField(structField);
        }

        @Override
        protected List<String> getFieldOrder() {
            return List.of("dummy0", "dummy1", "count", "array");
        }
    }

    public static void main(String[] args) {
        var va0 = new VarArray(new byte[] { 1, 2, 3, 4, 5, 6, 7 });
        va0.dummy0 = 0x4321;
        va0.dummy1 = 0xabcdef;
        va0.write();

        var va1 = new VarArray();
        va1.dummy0 = 0x4321;
        va1.dummy1 = 0xabcdef;
        va1.write();

        print(new Pointer(Pointer.nativeValue(va0.getPointer())));
        print(new Pointer(Pointer.nativeValue(va1.getPointer())));
    }

    private static void print(Pointer p) {
        var va = new VarArray(p);
        va.read();
        System.out.println(va);
        System.out.println("byte[] array=" + Arrays.toString(va.array));
        System.out.println();
    }
}

输出：

JnaStructTester$VarArray(native@0x7fd85cf1ffb0) (12 bytes) {
  short dummy0@0=4321
  int dummy1@4=abcdef
  byte count@8=7
  byte array[7]@9=[B@4f2410ac
}
byte[] array=[1, 2, 3, 4, 5, 6, 7]

JnaStructTester$VarArray(native@0x7fd85cf20690) (12 bytes) {
  short dummy0@0=4321
  int dummy1@4=abcdef
  byte count@8=0
  byte array[0]@9=[B@722c41f4
}
byte[] array=[]

我只在我狭窄的用例中测试过这个，如果调用其他方法，它可能不起作用 Structure .

JavaArraysstructurejna

1条答案

按热度按时间
pu82cl6c

pu82cl6c1#

我确实认为有两种结构的解决方案是合理的解决方案，阵列版本扩展了另一种结构，但只是添加了新字段。jna 5.x具有 @FieldOrder 注解，这大大减少了样板文件。你的结构会很简单：

@FieldOrder({"dummy0", "dummy1", "count"})
public class VarArray extends Structure {
    public byte dummy0;
    public short dummy1;
    public int count;
}

@FieldOrder({"dummy0", "dummy1", "count", "array"})
public class VarArrayX extends VarArray  {
    public byte[] array = new byte[1];

    public VarArrayX(int arraySize) {
        array = new byte[arraySize];
        super.count = arraySize;
        allocateMemory();
    }
}

如果您想用指针初始化，除了添加构造函数之外，这应该足够了。
但是，您可以通过对 FieldOrder . jna的内存分配取决于使用 getFieldList() 以及 getFieldOrder() 方法（新注解删除了对其的样板文件要求）。
您可以在结构中保留数组分配，但要改变 getFieldOrder() 重写以跳过定义数组的字段（如果数组大小为零），对 getFieldList() . 在jna的linux-libcMap中编写sysinfo结构时，我必须处理这种情况。主要结构包括：

public byte[] _f = new byte[PADDING_SIZE];

但是 getFieldList() 覆盖包括：

if (PADDING_SIZE == 0) {
    Iterator<Field> fieldIterator = fields.iterator();
    while (fieldIterator.hasNext()) {
        Field field = fieldIterator.next();
        if ("_f".equals(field.getName())) {
            fieldIterator.remove();
        }
    }
}

以及 getFieldOrder() 包括：

if (PADDING_SIZE == 0) {
    fieldOrder.remove("_f");
}

类似的条件删除 _f_unused 中的字段 Statvfs 同一文件中的结构。
就你的结构而言，只要你知道 count 在示例化结构之前，类似这样的操作应该有效（未经测试）：

public static class VarArray extends Structure {
    public byte dummy0;
    public short dummy1;
    public int count;
    public byte[] array = new byte[1];

    public VarArray(int arraySize) {
        array = new byte[arraySize];
        count = arraySize;
        allocateMemory();
    }

    @Override
    protected List<String> getFieldOrder() {
        if (count == 0) {
            return List.of("dummy0", "dummy1", "count");
        } else {
            return List.of("dummy0", "dummy1", "count", "array");
        }
    }

    // do the same for getFieldList()
}
赞(0）分享  回复(0）举报  2021-06-30
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com