/** * works only if change tracking is enabled */ public FSTStructChange finishChangeTracking() { tracker.snapshotChanges((int) getOffset(), getBase()); FSTStructChange res = tracker; tracker = null; return res; }
/** * allocate a Struct instance from an arbitrary template instance. * * @param aTemplate * @param <S> * @return */ public <S extends FSTStruct> S newStruct(S aTemplate) { return newStruct(aTemplate,alloc); }
/** * this will be avaiable for top level struct arrays only, embedded structarrays * will return null; * @return */ @NoAssist public E getTemplate() { return template; }
@NoAssist public E createPointer(int index) { if ( ! isOffHeap() ) throw new RuntimeException("must be offheap to call this"); E res = (E) elemsPointer(); res.___elementSize = res.getByteSize(); res.___offset+=index*res.___elementSize; return res; }
/** * @param b * @param index * @return a new allocated pointer matching struct type stored in b[] */ public static FSTStruct createStructPointer(Bytez b, int index) { return FSTStructFactory.getInstance().getStructPointerByOffset(b, index).detach(); }
public FSTStruct toOffHeap() { if (isOffHeap()) return this; return FSTStructFactory.getInstance().toStruct(this); }
public void applySnapshot(FSTStruct target) { Bytez arr = target.getBase(); int baseIdx = (int) target.getOffset(); int snapIdx = 0; for (int i = 0; i < curIndex; i++) { int changeOffset = changeOffsets[i]; int len = changeLength[i]; for ( int ii = 0; ii < len; ii++) { arr.put(baseIdx+changeOffset+ii,snapshot[snapIdx++]); } } }
public int hashCode() { if (!isOffHeap()) return onHeapHashcode(); return ___bytes.getInt(___offset) ^ ___bytes.getInt(___offset + getByteSize() - 4); }
public FSTStruct createPrimitiveArrayBasePointer(Bytez base, long objectBaseOffset /*offset of object containing array*/, int arrayStructIndex /*position of array header in struct*/) { int arrayElementZeroindex = base.getInt(objectBaseOffset+arrayStructIndex); // int len = unsafe.getInt(base,objectBaseOffset+arrayStructIndex+4); FSTStruct structPointer = new FSTStruct(); structPointer.baseOn(base,objectBaseOffset+arrayElementZeroindex,this); return structPointer; }
/** * create a new struct array of same type as template * @param size * @return */ public <X extends FSTStruct> StructArray<X> newArray(int size, X templ) { return newArray(size,templ,alloc); }
public void fillTypedArrayBasePointer(FSTStruct result, Bytez base, long objectBaseOffset /*offset of object containing array*/, int arrayStructIndex /*position of array header in struct*/) { int arrayElementZeroindex = base.getInt(objectBaseOffset+arrayStructIndex); int elemSiz = base.getInt(objectBaseOffset+arrayStructIndex+8); // int len = unsafe.getInt(base,objectBaseOffset+arrayStructIndex+4); // int clId = unsafe.getInt(base,objectBaseOffset+arrayStructIndex+12); result.baseOn(base, objectBaseOffset + arrayElementZeroindex, this); result.___elementSize = elemSiz; }
public boolean isNull() { return getClzId() <= 0; }
public void addChange(long offset, int len, String field) { addChange((long)offset,(long)len,field); }
/** * works only if change tracking is enabled */ public FSTStruct startChangeTracking() { tracker = new FSTStructChange(); return this; }
/** * @return the number of bytes used by the struct pointed to */ public int getByteSize() { if (!isOffHeap()) { return 0; } return ___bytes.getInt(___offset); }
public boolean pointsToNull() { return getClzId() <= 0; }
public void addChange(int offset, int len, String field) { addChange((long)offset,(long)len,field); }