JNIEXPORT void JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_setDataItems(JNIEnv *env, jobject _this, jlong idx, jint nelem, jobjectArray ja, jint ja_start)
{
try
{
DATAARRAY * pda = getDataArray(env, _this);
DATATYPE dt;
DataArrayGetDatatype(pda, &dt);
unsigned long len = env->GetArrayLength(ja);
if(len > numElements(pda))
{
len = numElements(pda);
}
if(dt==DT_DATAITEM)
{
DATAITEM di;
DataItemInit(&di);
for(unsigned long i=ja_start,j=idx;i<ja_start+nelem;i++,j++)
{
jobject var = env->GetObjectArrayElement(ja, i);
DATAITEM *di = getDataItem(env, var);
unsigned long x = j;
DataArrayPutElement(pda,&x,di);
}
}
else
{
ThrowFastCacheException(env, "dataarray type is not dataItem", -1);
}
}
catch(...)
{
ThrowFastCacheException(env, "dataarray error setting dataItem", -1);
}
}
JNIEXPORT void JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_fromDataItemArray(JNIEnv *env, jobject _this, jobjectArray a)
{
try
{
DATAARRAY * pda = getDataArray(env, _this);
DATATYPE dt;
DataArrayGetDatatype(pda, &dt);
unsigned long len = env->GetArrayLength(a);
if(len > numElements(pda))
{
len = numElements(pda);
}
if(dt==DT_DATAITEM)
{
for(unsigned long i=0;i<len;i++)
{
jobject var = env->GetObjectArrayElement(a, i);
DATAITEM * di = getDataItem(env, var);
unsigned long x = i;
if(di) DataArrayPutElement(pda,&x,di);
}
}
else
{
ThrowFastCacheException(env, "dataarray cannot be assigned from dataItem", -1);
}
}
catch(JNIException & ex)
{
JNIException::lastError = ex.getErrorCode();
}
}
JNIEXPORT void JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_getDataItems(JNIEnv *env, jobject _this, jlong idx, jint nelem, jobjectArray ja, jint ja_start)
{
try
{
DATAARRAY *da = getDataArray(env, _this);
unsigned long num = DataArrayGetElemsize(da);
DATATYPE dt;
DataArrayGetDatatype(da, &dt);
if(dt==DT_DATAITEM)
{
for(unsigned long i=0, j=ja_start;i<num;i++,j++)
{
unsigned long ix = i;
jobject newDataItem = env->NewObject(dataItemClass, dataItemCons);
DATAITEM *di = getDataItem(env, newDataItem);
DataArrayGetElement(da, &ix, (void*) di);
env->SetObjectArrayElement(ja, j, newDataItem);
}
}
else
{
ThrowFastCacheException(env, "dataarray type is not dataItem", -1);
}
}
catch(...)
{
ThrowFastCacheException(env, "dataarray error setting dataItem", -1);
}
}
DataItem DataLayout::item(bool hasSubitems) const
{
if (!hasSubitems) {
Q_ASSERT(m_widgets.count() == 1);
const WidgetLine &line = m_widgets.first();
return getDataItem(line.title, line.data);
} else {
return item();
}
}
void Appt::copyTo(Appt *precord)
{
int roundcount = 0;
precord->setType(getType());
precord->setKey(getKey());
for(roundcount = 0; roundcount < APPTNUMFIELDS; roundcount++)
{ precord->setDataItem(getDataItem(roundcount), roundcount);
}
precord->setItemUnChanged();
}
// compares 2 patient records, "THIS object, and the pointer passed
// Usually used to check if record changed before this new record
// will be commited to the db
bool Appt::compareTo(Appt *comp_record)
{
bool result = true;
for(int i = 0; i < APPTNUMFIELDS; i++)
{
if(getDataItem(i) != comp_record->getDataItem(i))
result = false;
}
return result;
}
static DataOffset
getUnicodeRowOffset (TextTableData *ttd, wchar_t character, int allocate) {
DataOffset planeOffset = getUnicodePlaneOffset(ttd, character, allocate);
if (!planeOffset) return 0;
{
UnicodePlaneEntry *plane = getDataItem(ttd->area, planeOffset);
unsigned int rowNumber = UNICODE_ROW_NUMBER(character);
DataOffset rowOffset = plane->rows[rowNumber];
if (!rowOffset && allocate) {
if (!allocateDataItem(ttd->area, &rowOffset,
sizeof(UnicodeRowEntry),
__alignof__(UnicodeRowEntry)))
return 0;
plane = getDataItem(ttd->area, planeOffset);
plane->rows[rowNumber] = rowOffset;
}
return rowOffset;
}
}
static DataOffset
getUnicodePlaneOffset (TextTableData *ttd, wchar_t character, int allocate) {
DataOffset groupOffset = getUnicodeGroupOffset(ttd, character, allocate);
if (!groupOffset) return 0;
{
UnicodeGroupEntry *group = getDataItem(ttd->area, groupOffset);
unsigned int planeNumber = UNICODE_PLANE_NUMBER(character);
DataOffset planeOffset = group->planes[planeNumber];
if (!planeOffset && allocate) {
if (!allocateDataItem(ttd->area, &planeOffset,
sizeof(UnicodePlaneEntry),
__alignof__(UnicodePlaneEntry)))
return 0;
group = getDataItem(ttd->area, groupOffset);
group->planes[planeNumber] = planeOffset;
}
return planeOffset;
}
}
JNIEXPORT void JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_setDataItem(JNIEnv *env, jobject _this, jlong idx, jobject s)
{
DATAARRAY *da = getDataArray(env, _this);
DATATYPE dt;
DataArrayGetDatatype(da, &dt);
DATAITEM *di = getDataItem(env, s);
if(dt==DT_DATAITEM)
{
DataArrayPutElement(da,(unsigned long *)&idx,di);
}
else
{
ThrowFastCacheException(env, "dataarray type is not dataItem/dispatch", -1);
}
}
JNIEXPORT jobjectArray JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_toDataItemArray(JNIEnv *env, jobject _this)
{
DATAARRAY *da = getDataArray(env, _this);
int num = DataArrayGetElemsize(da);
jobjectArray varr = env->NewObjectArray(num, dataItemClass, 0);
for(int i=0;i<num;i++)
{
unsigned long ix = i;
jobject newDataItem = env->NewObject(dataItemClass, dataItemCons);
DATAITEM *di = getDataItem(env, newDataItem);
DataArrayGetElement(da, &ix, (void*) di);
env->SetObjectArrayElement(varr, i, newDataItem);
}
return varr;
}
JNIEXPORT jobject JNICALL Java_org_adaptinet_sdk_fastcache_DataArray_getDataItem(JNIEnv *env, jobject _this, jlong idx)
{
DATAARRAY * pda = getDataArray(env, _this);
DATATYPE dt;
DataArrayGetDatatype(pda, &dt);
jobject newDataItem = env->NewObject(dataItemClass, dataItemCons);
DATAITEM *di = getDataItem(env, newDataItem);
if(dt==DT_DATAITEM)
{
DataArrayGetElement(pda, (unsigned long *)&idx, di);
}
else
{
ThrowFastCacheException(env, "dataarray type is not dataItem/dispatch", -1);
}
return newDataItem;
}
bool GalacticusReader::getItemInRow(DBDataSchema::DataObjDesc * thisItem, bool applyAsserters, bool applyConverters, void* result) {
//reroute constant items:
if(thisItem->getIsConstItem() == true) {
getConstItem(thisItem, result);
} else if (thisItem->getIsHeaderItem() == true) {
printf("We never told you to read headers...\n");
exit(EXIT_FAILURE);
} else {
getDataItem(thisItem, result);
}
//cout << " again ioutput: " << ioutput << endl;
//check assertions
//checkAssertions(thisItem, result);
//apply conversion
//applyConversions(thisItem, result);
return 0;
}
void *
getTextTableItem (TextTableData *ttd, TextTableOffset offset) {
return getDataItem(ttd->area, offset);
}
static UnicodeRowEntry *
getUnicodeRowEntry (TextTableData *ttd, wchar_t character, int allocate) {
DataOffset rowOffset = getUnicodeRowOffset(ttd, character, allocate);
if (!rowOffset) return NULL;
return getDataItem(ttd->area, rowOffset);
}
int
saveDataItem (DataArea *area, DataOffset *offset, const void *item, size_t size, size_t alignment) {
if (!allocateDataItem(area, offset, size, alignment)) return 0;
memcpy(getDataItem(area, *offset), item, size);
return 1;
}
