/** * @return hash code for this structure's pointer. */ @Override public int hashCode() { Pointer p = getPointer(); if (p != null) { return getPointer().hashCode(); } return getClass().hashCode(); }
/** * @return whether the given structure's type and pointer match. */ @Override public boolean equals(Object o) { return o instanceof Structure && o.getClass() == getClass() && ((Structure)o).getPointer().equals(getPointer()); }
private static void structureArrayCheck(Structure[] ss) { if (Structure.ByReference[].class.isAssignableFrom(ss.getClass())) { return; } Pointer base = ss[0].getPointer(); int size = ss[0].size(); for (int si=1;si < ss.length;si++) { if (ss[si].getPointer().peer != base.peer + size*si) { String msg = "Structure array elements must use" + " contiguous memory (bad backing address at Structure array index " + si + ")"; throw new IllegalArgumentException(msg); } } }
private int indexOf(Structure s1) { for (int i=0;i < count;i++) { Structure s2 = elements[i]; if (s1 == s2 || (s1.getClass() == s2.getClass() && s1.size() == s2.size() && s1.getPointer().equals(s2.getPointer()))) { return i; } } return -1; } @Override
/** * Call the native function, returning a struct by value. * * @param function Present to prevent the GC to collect the Function object * prematurely * @param fp function pointer * @param callFlags calling convention to be used * @param args Arguments to pass to the native function * * @return the passed-in Structure */ static Structure invokeStructure(Function function, long fp, int callFlags, Object[] args, Structure s) { invokeStructure(function, fp, callFlags, args, s.getPointer().peer, s.getTypeInfo().peer); return s; }
return value; return ((Structure)value).getPointer(); } else if (cls == boolean.class || cls == Boolean.class) { return Boolean.TRUE.equals(value) ?
reading().put(getPointer(), this); if (reading().get(getPointer()) == this) { reading().remove(getPointer());
private String toString(int indent, boolean showContents, boolean dumpMemory) { ensureAllocated(); String LS = System.getProperty("line.separator"); String name = format(getClass()) + "(" + getPointer() + ")"; if (!(getPointer() instanceof Memory)) { name += " (" + size() + " bytes)"; final int BYTES_PER_ROW = 4; contents += LS + "memory dump" + LS; byte[] buf = getPointer().getByteArray(0, size()); for (int i=0;i < buf.length;i++) { if ((i % BYTES_PER_ROW) == 0) contents += "[";
/** Return whether the given Structure's backing data is identical to * this one, optionally clearing and re-writing native memory before checking. * @param s Structure to compare * @param clear whether to clear native memory * @return equality result */ public boolean dataEquals(Structure s, boolean clear) { if (clear) { s.getPointer().clear(s.size()); s.write(); getPointer().clear(size()); write(); } byte[] data = s.getPointer().getByteArray(0, s.size()); byte[] ref = getPointer().getByteArray(0, size()); if (data.length == ref.length) { for (int i=0;i < data.length;i++) { if (data[i] != ref[i]) { return false; } } return true; } return false; }
/** Only keep the original structure if its native address is unchanged. * Otherwise replace it with a new object. * @param type Structure subclass * @param s Original Structure object * @param address the native <code>struct *</code> * @return Updated <code>Structure.ByReference</code> object */ static <T extends Structure> T updateStructureByReference(Class<T> type, T s, Pointer address) { if (address == null) { s = null; } else { if (s == null || !address.equals(s.getPointer())) { Structure s1 = reading().get(address); if (s1 != null && type.equals(s1.getClass())) { s = (T) s1; s.autoRead(); } else { s = newInstance(type, address); s.conditionalAutoRead(); } } else { s.autoRead(); } } return s; }
return struct.getPointer(); } else if (arg instanceof Callback) { Pointer[] pointers = new Pointer[ss.length + 1]; for (int i=0;i < ss.length;i++) { pointers[i] = ss[i] != null ? ss[i].getPointer() : null; } else if (ss[0] == null) { Structure.newInstance((Class<? extends Structure>) type).toArray(ss); return ss[0].getPointer(); } else { Structure.autoWrite(ss); return ss[0].getPointer();
Structure s = (Structure)value; if (Structure.ByReference.class.isAssignableFrom(type)) { setPointer(offset, s == null ? null : s.getPointer()); if (s != null) { s.autoWrite();
byte[] buf = new byte[s.size()]; ((Pointer)value).read(0, buf, 0, buf.length); s.getPointer().write(0, buf, 0, buf.length); s.read(); value = s;
buf[i] = null; } else { buf[i] = sbuf[i].getPointer(); sbuf[i].write();
/** * @return hash code for this structure's pointer. */ @Override public int hashCode() { Pointer p = getPointer(); if (p != null) { return getPointer().hashCode(); } return getClass().hashCode(); }
public static String ref(Structure struct) { if (struct == null) return "null"; else return struct.getPointer().toString(); }
public static String ref(Structure struct) { if (struct == null) return "null"; else return struct.getPointer().toString(); }
private static class MemberOrder { public int first; public int middle; public int last; }
private Structure copyBufferToStructure(Pointer buffer, Structure structure) { int byteCount = structure.size(); memcpy(structure.getPointer(), buffer, byteCount); structure.read(); return structure; }
private Memory bufferForStructureByValue(Structure methodCallResult) { methodCallResult.write(); int byteCount = methodCallResult.size(); Memory buffer = new Memory(byteCount); memcpy(buffer, methodCallResult.getPointer(), byteCount); return buffer; }