OCerror
ocdata_ithfield(OCstate* state, OCdata* container, size_t index, OCdata** fieldp)
{
OCdata* field;
OCnode* pattern;
OCASSERT(state != NULL);
OCASSERT(container != NULL);
pattern = container->pattern;
if(!ociscontainer(pattern->octype))
return OCTHROW(OC_EBADTYPE);
/* Validate index */
if(index >= container->ninstances)
return OCTHROW(OC_EINDEX);
field = container->instances[index];
if(fieldp) *fieldp = field;
octrace("ithfield", state, field);
return OC_NOERR;
}
/* Move to the ith sequence record. */
OCerror
ocdata_ithrecord(OCstate* state, OCdata* data,
size_t index, /* record number */
OCdata** recordp
)
{
int stat = OC_NOERR;
OCdata* record;
OCnode* pattern;
OCASSERT(state != NULL);
OCASSERT(data != NULL);
pattern = data->pattern;
/* Must be a Sequence */
if(pattern->octype != OC_Sequence
|| !fisset(data->datamode,OCDT_SEQUENCE))
return OCTHROW(OC_EBADTYPE);
/* Validate index */
if(index >= data->ninstances)
return OCTHROW(OC_EINDEX);
record = data->instances[index];
if(recordp) *recordp = record;
octrace("ithrecord", state, record);
return OCTHROW(stat);
}
OCerror
ocdata_read(OCstate* state, OCdata* data, size_t start, size_t count,
void* memory, size_t memsize)
{
int stat = OC_NOERR;
XXDR* xdrs;
OCtype etype, octype;
int isscalar;
size_t elemsize, totalsize, countsize;
OCnode* pattern;
octrace("read", state, data);
assert(state != NULL);
assert(data != NULL);
assert(memory != NULL);
assert(memsize > 0);
pattern = data->pattern;
octype = pattern->octype;
assert(octype == OC_Atomic);
etype = pattern->etype;
isscalar = (pattern->array.rank == 0 ? 1 : 0);
/* validate memory space*/
elemsize = octypesize(etype);
totalsize = elemsize*data->ninstances;
countsize = elemsize*count;
if(totalsize < countsize || memsize < countsize)
return OCTHROW(OC_EINVAL);
/* Get XXDR* */
xdrs = pattern->root->tree->data.xdrs;
if(isscalar) {
/* Extract the data */
stat = ocread(data,xdrs,(char*)memory,memsize,0,1);
} else {
/* Validate the start and count */
if(start >= data->ninstances
|| (start+count) > data->ninstances)
return OCTHROW(OC_EINVALCOORDS);
/* Extract the data */
stat = ocread(data,xdrs,(char*)memory,memsize,start,count);
}
return OCTHROW(stat);
}
OCerror
ocdata_root(OCstate* state, OCdata* data, OCdata** rootp)
{
OCdata* root;
OCnode* pattern;
OCASSERT(state != NULL);
pattern = data->pattern;
root = pattern->tree->data.data;
if(rootp) *rootp = root;
octrace("root", state, root);
return OC_NOERR;
}
/* Use this to attach to a data tree for a DATADDS */
OCerror
ocdata_getroot(OCstate* state, OCnode* root, OCdata** datap)
{
OCdata* data;
assert(root->tree->dxdclass == OCDATADDS);
assert(root->octype == OC_Dataset);
if(root->tree->data.data == NULL)
return OCTHROW(OC_ENODATA);
data = root->tree->data.data;
if(datap) *datap = data;
octrace("attach",state,data);
return OCTHROW(OC_NOERR);
}
OCerror
ocdata_container(OCstate* state, OCdata* data, OCdata** containerp)
{
OCdata* container;
OCnode* pattern;
OCASSERT(state != NULL);
pattern = data->pattern;
if(pattern->container == NULL)
return OCTHROW(OC_EBADTYPE);
container = data->container;
if(container == NULL)
return OCTHROW(OC_EBADTYPE);
if(containerp) *containerp = container;
octrace("container", state, container);
return OC_NOERR;
}
OCerror
ocdata_ithelement(OCstate* state, OCdata* data, size_t* indices, OCdata** elementp)
{
int stat = OC_NOERR;
OCdata* element;
OCnode* pattern;
size_t index,rank;
OCASSERT(state != NULL);
OCASSERT(data != NULL);
pattern = data->pattern;
rank = pattern->array.rank;
/* Must be a dimensioned Structure */
if(pattern->octype != OC_Structure || rank == 0)
return OCTHROW(OC_EBADTYPE);
/* Validate indices */
if(!ocvalidateindices(rank,pattern->array.sizes,indices))
return OCTHROW(OC_EINVALCOORDS);
/* compute linearized index */
index = ocarrayoffset(rank,pattern->array.sizes,indices);
if(index >= data->ninstances)
return OCTHROW(OC_EINDEX);
element = data->instances[index];
if(elementp) *elementp = element;
octrace("ithelement", state, element);
return OCTHROW(stat);
}