public StructureMembers(StructureMembers from) { this.name = from.name; members = new ArrayList<>(from.getMembers().size()); for (Member m : from.members) { Member nm = new Member(m); // make copy - without the data info addMember( nm); if (m.members != null) // recurse nm.members = new StructureMembers(m.members); } }
/** * Find a member by its name. * * @param memberName find member with this name * @return StructureMembers.Member matching the name, or null if not found */ public StructureMembers.Member findMember(String memberName) { return members.findMember(memberName); }
/** * Get a list structure member names. * @return the structure members. */ public List<String> getStructureMemberNames() { return members.getMemberNames(); }
public void add(StructureData sdata) { for (StructureMembers.Member m : sdata.getMembers()) { if (this.members.findMember(m.getName()) == null) { this.members.addMember(m); proxy.put(m, sdata); } } }
public PointFeatureCopyFactory(PointFeature proto) throws IOException { StructureData sdata = proto.getFeatureData(); sm = new StructureMembers(sdata.getStructureMembers()); sizeInBytes = OBJECT_SIZE + POINTER_SIZE + // PointFeatureCopy - 1 pointer 48 2 * 8 + 2 * POINTER_SIZE + // PointFeatureImpl - 2 doubles and 2 pointers 32 OBJECT_SIZE + 3 * 8 + // Earth Location - 3 doubles 64 OBJECT_SIZE + // StructureDataDeep 4 + POINTER_SIZE + // StructureDataA - 1 int and 1 pointer OBJECT_SIZE + 4 + 2 * POINTER_SIZE + // ArrayStructureBB - 1 int and 2 pointers (heap is optional) 2 * POINTER_SIZE + 4 + // ArrayStructure - 2 pointers and an int OBJECT_SIZE + 8 * 4 + 8 + POINTER_SIZE + // ByteBuffer - 8 ints, 1 long, 1 pointer sm.getStructureSize(); // LOOK vlens, Strings (Heap Size) }
private StructureMembers createStructureMembers(UserType userType) { StructureMembers sm = new StructureMembers(userType.name); for (Field fld : userType.flds) { StructureMembers.Member m = sm.addMember(fld.name, null, null, fld.ctype.dt, fld.dims); m.setDataParam(fld.offset); /* This should already have been taken care of if(fld.ctype.isVlen) {m.setShape(new int[]{-1}); } */ if (fld.ctype.dt == DataType.STRUCTURE) { UserType nested_utype = userTypes.get(fld.fldtypeid); StructureMembers nested_sm = createStructureMembers(nested_utype); m.setStructureMembers(nested_sm); } } sm.setStructureSize(userType.size); return sm; }
StructureMembers sm = new StructureMembers("manLevel"); Dimension manDim = ncfile.findDimension("manLevel"); Structure record = (Structure) ncfile.findVariable("record"); sm.addMember(v.getShortName(), v.getDescription(), v.getUnitsString(), v.getDataType(), new int[0]); // scalar List<String> names = sm.getMemberNames(); for (String mname : names) { manAS.setMemberArray(mname, sdata.getArray(mname));
/** * @return List of StructureMembers.Member */ public List<StructureMembers.Member> getMembers() { return members.getMembers(); }
/** * Read data * * @param name Variable name, * @param bos Data buffer, * @param vinfo variable info, * @return the arraystructure of circle struct data */ public ArrayStructure readCircleStructData(String name, ByteBuffer bos, Nidsheader.Vinfo vinfo) throws IOException, InvalidRangeException { int[] pos = vinfo.pos; int size = pos.length; Structure pdata = (Structure) ncfile.findVariable(name); int recsize = pos[1] - pos[0]; // each record must be all the same size for (int i = 1; i < size; i++) { int r = pos[i] - pos[i - 1]; if (r != recsize) System.out.println(" PROBLEM at " + i + " == " + r); } StructureMembers members = pdata.makeStructureMembers(); members.findMember("x_center").setDataParam(0); members.findMember("y_center").setDataParam(2); members.findMember("radius").setDataParam(4); members.setStructureSize(recsize); return new ArrayStructureBBpos(members, new int[]{size}, bos, pos); }
/** * Set the offsets, based on m.getSizeBytes(). * Also sets members.setStructureSize(). * @param members set offsets for these members * @return the total size */ public static int setOffsets(StructureMembers members) { int offset = 0; for (StructureMembers.Member m : members.getMembers()) { m.setDataParam(offset); offset += m.getSizeBytes(); // set inner offsets (starts again at 0) if (m.getStructureMembers() != null) setOffsets(m.getStructureMembers()); } members.setStructureSize(offset); return offset; }
static public StructureData make(String name, Object value) { StructureMembers members = new StructureMembers(""); DataType dtype = DataType.getType(value.getClass()); StructureMembers.Member m = members.addMember(name, null, null, dtype, new int[]{1}); StructureDataW sw = new StructureDataW(members); Array dataArray = Array.factory(dtype, new int[]{1}); dataArray.setObject(dataArray.getIndex(), value); sw.setMemberData(m, dataArray); return sw; }
public static int showOffsets(StructureMembers members, Indent indent, Formatter f) { int offset = 0; for (StructureMembers.Member m : members.getMembers()) { f.format("%s%s offset=%d (%d %s = %d bytes)%n", indent, m.getName(), m.getDataParam(), m.getSize(), m.getDataType(), m.getSizeBytes()); if (m.getStructureMembers() != null) { indent.incr(); StructureMembers nested = m.getStructureMembers(); f.format("%n%s%s == %d bytes%n", indent, nested.getName(), nested.getStructureSize()); showOffsets(nested, indent, f); indent.decr(); } } return offset; }
/** * Make deep copy from a StructureData to a ArrayStructureBB whose data is contained in a ByteBuffer * @param sdata original ArrayStructure. * @return ArrayStructureBB with all data self contained */ static public ArrayStructureBB copyToArrayBB(StructureData sdata) { return copyToArrayBB(sdata, new StructureMembers(sdata.getStructureMembers()), ByteOrder.BIG_ENDIAN); }
public Member addMember(String name, String desc, String units, DataType dtype, int[] shape) { Member m = new Member(name, desc, units, dtype, shape); addMember(m); return m; }
public void showInternal(Formatter f, Indent indent) { f.format("%sname='%s' desc='%s' units='%s' dtype=%s size=%d dataObject=%s dataParam=%d", indent, name, desc, units, dtype, size, dataObject, dataParam); if (members != null) { indent.incr(); f.format("%n%sNested members %s%n", indent, members.getName()); for (StructureMembers.Member m : members.getMembers()) m.showInternal(f, indent); indent.decr(); } f.format("%n"); }
byte[] data = new byte[sm.getStructureSize()]; ByteBuffer bbdata = ByteBuffer.wrap(data); for (String mbrName : sm.getMemberNames()) { if (mbrName.equals(TIME)) { bbdata.putDouble(stroke.secs);
/** * Get the size of each StructureData object in bytes. * * @return the size of each StructureData object in bytes. */ public int getStructureSize() { return members.getStructureSize(); }
private ArrayStructure convertStructure(Structure s, Layout layout, int[] shape, byte[] byteArray) throws IOException, InvalidRangeException { // create StructureMembers - must set offsets StructureMembers sm = s.makeStructureMembers(); int calcSize = ArrayStructureBB.setOffsets(sm); // standard //ArrayStructureBB.showOffsets(sm, new Indent(2), new Formatter(System.out)); // special offset setting boolean hasHeap = convertStructure(s, sm); //ArrayStructureBB.showOffsets(sm, new Indent(2), new Formatter(System.out)); int recSize = layout.getElemSize(); if (recSize < calcSize) { log.error("calcSize = %d actualSize = %d%n", calcSize, recSize); throw new IOException("H5iosp illegal structure size " + s.getFullName()); } sm.setStructureSize(recSize); // place data into an ArrayStructureBB ByteBuffer bb = ByteBuffer.wrap(byteArray); ArrayStructureBB asbb = new ArrayStructureBB(sm, shape, bb, 0); // strings are stored on the heap, and must be read separately if (hasHeap) { int destPos = 0; for (int i = 0; i < layout.getTotalNelems(); i++) { // loop over each structure convertHeap(asbb, destPos, sm); destPos += layout.getElemSize(); } } return asbb; }
/** * Get the total size of the Structure in bytes. * * @return the total size of the Structure in bytes. */ public int getStructureSize() { if (structureSize < 0) calcStructureSize(); return structureSize; }
private StructureMembers createStructureMembers(UserType userType) { StructureMembers sm = new StructureMembers(userType.name); for (Field fld : userType.flds) { StructureMembers.Member m = sm.addMember(fld.name, null, null, fld.ctype.dt, fld.dims); m.setDataParam(fld.offset); if (fld.ctype.isVen) { m.setShape(new int[]{-1}); } if (fld.ctype.dt == DataType.STRUCTURE) { UserType nested_utype = userTypes.get(fld.fldtypeid); StructureMembers nested_sm = createStructureMembers(nested_utype); m.setStructureMembers(nested_sm); } } sm.setStructureSize(userType.size); return sm; }