java - JNA:如何在结构中指定可变长度(0+)数组?
问题描述
示例结构,其中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
。
如果计数为 0,则声明默认值array = new byte[1]
将从未分配的地址读取。
删除该array
字段可以读取,因为我可以从指针偏移量访问字节Structure.size()
[编辑:不正确,取决于填充]。但是,为了分配一个新实例,我需要手动确定字段大小和对齐填充,以便分配正确的内存大小。
我有一个使用两种类型的解决方案 - 一种不用于本地分配和 0 计数 Java 分配的实例,另一种用于 Java 分配的 1+ 计数实例array
的子类型。array
这似乎相当臃肿,尤其是对于所需的样板代码。
有没有更好的办法?
或者也许是一种计算字段大小和对齐方式的简单方法,以便一种类型就足够了?
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 的建议,这是一个不错的解决方案。
不可能根据数组是否为空来动态修改字段列表。当不包含可变数组字段时,布局会静态缓存,因此具有非空数组的未来实例将失败。反而:
- 数组在 中调整
ensureAllocated()
,以避免空数组错误。 writeField()
仅当数组非空时才写入字段。readField()
从已读取的 count 中设置数组大小,如果 count 为 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
。
解决方案
我确实认为具有两个结构的解决方案是一个合理的解决方案,其中数组版本扩展另一个但只是添加新字段。@FieldOrder
使用具有注释的 JNA 5.X 大大减少了您对“样板膨胀”的担忧,这大大减少了样板。您的结构将相当简单:
@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()
andgetFieldOrder()
方法定义的字段顺序(新注释删除了样板要求)。
您可以将数组分配保留在结构中,但更改getFieldOrder()
覆盖以跳过定义数组的字段,以防它的大小为零,对getFieldList()
. 在 JNA 的 Linux LibC 映射中编写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()
}
推荐阅读
- javascript - 如何使函数仅与每个克隆的 div 单独运行而不与原始 div 一起运行
- python - Python中时间间隔的itertools.groupby问题
- big-o - 函数示例的 Big-O
- c# - 调用 Microsoft.Azure.CognitiveServices.Vision.Face.FaceClient.DetectWithStreamAsync 返回“操作返回了无效的状态代码‘NotFound’”
- json - 创建一个 json 路径表达式以获取所有特定的子元素,不包括第一个父元素
- jwt - 无法使用 Boxr gem Ruby SDK for Box API 通过 id 获取文件夹
- haskell - 看似合法的 Eta 减少导致问题
- java - 消费者/生产者问题:因消费缓慢而暂停生产
- r - 如何避免“geom_density”中奇怪的下垂边缘
- tcl - 根据 tcl 中的总和对列表中的元素进行分组