/* Return all the OCobjects associated with a tree with specified root */
OCobject*
oc_inq_objects(OCconnection conn, OCobject root0)
{
unsigned int i;
OCstate* state;
OCnode* root;
OClist* nodes;
OCobject* objects = NULL;
unsigned int nobjects;
OCVERIFYX(OCstate*,state,conn,OCNULL);
OCDEREF(OCstate*,state,conn);
OCVERIFYX(OCnode*,root,root0,OCNULL);
OCDEREF(OCnode*,root,root0);
if(root == NULL) return NULL;
root = root->root;
if(root == NULL) return NULL;
nodes = root->tree->nodes;
nobjects = oclistlength(nodes);
if(nodes != NULL && nobjects > 0) {
size_t len = sizeof(OCobject)*(1+nobjects);
objects = (OCobject*)ocmalloc(len);
for(i=0;i<oclistlength(nodes);i++) {
objects[i] = (OCobject)oclistget(nodes,i);
}
objects[nobjects] = OCNULL; /* null terminate */
}
return objects;
}
OCerror
oc_inq_object(OCconnection conn,
OCobject node0,
char** namep,
OCtype* objecttypep,
OCtype* primitivetypep, /* if objecttype == OC_Primitive */
OCobject* containerp,
unsigned int* rankp,
unsigned int* subnodesp,
unsigned int* nattrp)
{
OCstate* state;
OCnode* node;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
if(namep) *namep = (node->name == NULL?NULL:strdup(node->name));
if(objecttypep) *objecttypep = node->octype;
if(primitivetypep) *primitivetypep = node->etype;
if(rankp) *rankp = node->array.rank;
if(containerp) *containerp = (OCobject)node->container;
if(subnodesp) *subnodesp = oclistlength(node->subnodes);
if(nattrp) {
if(node->octype == OC_Attribute) {
*nattrp = oclistlength(node->att.values);
} else {
*nattrp = oclistlength(node->attributes);
}
}
return OC_NOERR;
}
static int
mergedas1(OCnode* dds, OCnode* das)
{
int i,j;
int stat = OC_NOERR;
if(dds->attributes == NULL) dds->attributes = oclistnew();
/* assign the simple attributes in the das set to this dds node*/
for(i=0;i<oclistlength(das->subnodes);i++) {
OCnode* attnode = (OCnode*)oclistget(das->subnodes,i);
if(attnode->octype == OC_Attribute) {
Attribute* att = makeattribute(attnode->name,
attnode->etype,
attnode->att.values);
oclistpush(dds->attributes,(ocelem)att);
}
}
/* Try to merge any enclosed sets with subnodes of dds*/
for(i=0;i<oclistlength(das->subnodes);i++) {
OCnode* dasnode = (OCnode*)oclistget(das->subnodes,i);
int match = 0;
if(dasnode->octype == OC_Attribute) continue; /* already dealt with above*/
for(j=0;j<oclistlength(dds->subnodes) && !match;j++) {
OCnode* ddsnode = (OCnode*)oclistget(dds->subnodes,j);
if(strcmp(dasnode->name,ddsnode->name) == 0) {
match = 1;
stat = mergedas1(ddsnode,dasnode);
if(stat != OC_NOERR) break;
}
}
if(!match) {marklostattribute(dasnode);}
}
return THROW(stat);
}
void
ocfreenodes(OClist* nodes)
{
unsigned int i,j;
for(i=0;i<oclistlength(nodes);i++) {
OCnode* node = (OCnode*)oclistget(nodes,i);
ocfree(node->name);
ocfree(node->fullname);
while(oclistlength(node->att.values) > 0) {
char* value = (char*)oclistpop(node->att.values);
ocfree(value);
}
while(oclistlength(node->attributes) > 0) {
OCattribute* attr = (OCattribute*)oclistpop(node->attributes);
ocfree(attr->name);
/* If the attribute type is string, then we need to free them*/
if(attr->etype == OC_String || attr->etype == OC_URL) {
char** strings = (char**)attr->values;
for(j=0;j<attr->nvalues;j++) {ocfree(*strings); strings++;}
}
ocfree(attr->values);
ocfree(attr);
}
if(node->array.dimensions != NULL) oclistfree(node->array.dimensions);
if(node->subnodes != NULL) oclistfree(node->subnodes);
if(node->att.values != NULL) oclistfree(node->att.values);
if(node->attributes != NULL) oclistfree(node->attributes);
ocfree(node);
}
oclistfree(nodes);
}
static size_t
maxindexfor(OCnode* node, OCmode srcmode)
{
switch (srcmode) {
case Dimmode:
if(node->octype == OC_Sequence) return 0;
if(node->octype == OC_Primitive) return 1;
return oclistlength(node->subnodes);
case Recordmode:
if(node->array.rank > 0) return totaldimsize(node);
if(node->octype == OC_Primitive) return 1;
return oclistlength(node->subnodes);
case Datamode:
return 1;
case Nullmode:
case Fieldmode:
if(node->array.rank > 0) return totaldimsize(node);
if(node->octype == OC_Primitive) return 1;
if(node->octype == OC_Sequence) return 0;
return oclistlength(node->subnodes);
case Emptymode:
default:
OCPANIC1("No defined mode transition: %d",(int)srcmode);
break;
}
return oclistlength(node->subnodes);
}
static OCerror
occorrelater(OCnode* dds, OCnode* dxd)
{
int i,j;
OCerror ocstat = OC_NOERR;
if(dds->octype != dxd->octype) {
THROWCHK((ocstat = OC_EINVAL)); goto fail;
}
if(dxd->name != NULL && dxd->name != NULL
&& strcmp(dxd->name,dds->name) != 0) {
THROWCHK((ocstat = OC_EINVAL)); goto fail;
} else if(dxd->name != dxd->name) { /* test NULL==NULL */
THROWCHK((ocstat = OC_EINVAL)); goto fail;
}
if(dxd->array.rank != dds->array.rank) {
THROWCHK((ocstat = OC_EINVAL)); goto fail;
}
dds->datadds = dxd;
switch (dds->octype) {
case OC_Dataset:
case OC_Structure:
case OC_Grid:
case OC_Sequence:
/* Remember: there may be fewer datadds fields than dds fields */
for(i=0;i<oclistlength(dxd->subnodes);i++) {
OCnode* dxd1 = (OCnode*)oclistget(dxd->subnodes,i);
for(j=0;j<oclistlength(dds->subnodes);j++) {
OCnode* dds1 = (OCnode*)oclistget(dds->subnodes,j);
if(strcmp(dxd1->name,dds1->name) == 0) {
ocstat = occorrelater(dds1,dxd1);
if(ocstat != OC_NOERR) {THROWCHK(ocstat); goto fail;}
break;
}
}
}
break;
case OC_Dimension:
case OC_Primitive:
break;
default: OCPANIC1("unexpected node type: %d",dds->octype);
}
/* Correlate the dimensions */
if(dds->array.rank > 0) {
for(i=0;i<oclistlength(dxd->subnodes);i++) {
OCnode* ddsdim = (OCnode*)oclistget(dds->array.dimensions,i);
OCnode* dxddim = (OCnode*)oclistget(dxd->array.dimensions,i);
ocstat = occorrelater(ddsdim,dxddim);
if(!ocstat) goto fail;
}
}
fail:
return THROW(ocstat);
}
static char*
scopeduplicates(OClist* list)
{
unsigned int i,j;
for(i=0;i<oclistlength(list);i++) {
OCnode* io = (OCnode*)oclistget(list,i);
for(j=i+1;j<oclistlength(list);j++) {
OCnode* jo = (OCnode*)oclistget(list,j);
if(strcmp(io->name,jo->name)==0)
return io->name;
}
}
return NULL;
}
void
ocfreeprojectionclause(OCprojectionclause* clause)
{
if(clause->target != NULL) free(clause->target);
while(oclistlength(clause->indexsets) > 0) {
OClist* slices = (OClist*)oclistpop(clause->indexsets);
while(oclistlength(slices) > 0) {
OCslice* slice = (OCslice*)oclistpop(slices);
if(slice != NULL) free(slice);
}
oclistfree(slices);
}
oclistfree(clause->indexsets);
free(clause);
}
int
ocrootcontent(OCstate* state, OCnode* root, OCcontent* content)
{
OCtree* tree;
if(state == NULL || root == NULL || content == NULL)
return OCTHROW(OC_EINVAL);
if(root->tree == NULL) return OCTHROW(OC_EINVAL);
tree = root->tree;
if(tree->dxdclass != OCDATADDS) return OCTHROW(OC_ENODATA);
if(tree->nodes == NULL) return OCTHROW(OC_EINVAL);
if(tree->data.memdata == NULL && tree->data.xdrs == NULL)
return OCTHROW(OC_EXDR);
ocresetcontent(state,content);
content->state = state; /* make sure*/
content->mode = Fieldmode;
content->node = root;
content->tree = tree;
content->maxindex = oclistlength(content->node->subnodes);
if(tree->data.memdata == NULL) {
content->xdrpos.offset = tree->data.bod;
content->xdrpos.valid = 1;
} else {
content->memdata = tree->data.memdata;
content->mode = tree->data.memdata->mode;
}
return OCTHROW(OC_NOERR);
}
void
occlose(OCstate* state)
{
unsigned int i;
if(state == NULL) return;
/* Warning: ocfreeroot will attempt to remove the root from state->trees */
/* Ok in this case because we are popping the root out of state->trees */
for(i=0;i<oclistlength(state->trees);i++) {
OCnode* root = (OCnode*)oclistpop(state->trees);
ocroot_free(root);
}
oclistfree(state->trees);
ocurifree(state->uri);
ocbytesfree(state->packet);
ocfree(state->error.code);
ocfree(state->error.message);
ocfree(state->curlflags.useragent);
if(state->curlflags.cookiejar) {
unlink(state->curlflags.cookiejar);
ocfree(state->curlflags.cookiejar);
}
ocfree(state->ssl.certificate);
ocfree(state->ssl.key);
ocfree(state->ssl.keypasswd);
ocfree(state->ssl.cainfo);
ocfree(state->ssl.capath);
ocfree(state->proxy.host);
ocfree(state->creds.username);
ocfree(state->creds.password);
if(state->curl != NULL) occurlclose(state->curl);
ocfree(state);
}
OCerror
oc_inq_attr(OCconnection conn, OCobject node0, unsigned int i,
char** namep, OCtype* octypep, unsigned int* nvaluesp, void** valuesp)
{
OCstate* state;
OCnode* node;
OCattribute* attr;
unsigned int nattrs;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
nattrs = oclistlength(node->attributes);
if(i >= nattrs) return OC_EINVAL;
attr = (OCattribute*)oclistget(node->attributes,i);
if(namep) *namep = strdup(attr->name);
if(octypep) *octypep = attr->etype;
if(nvaluesp) *nvaluesp = attr->nvalues;
if(valuesp && attr->nvalues > 0) {
void* memory = NULL;
memory = oclinearize(attr->etype,attr->nvalues,attr->values);
*valuesp = memory;
}
return OC_NOERR;
}
/* This procedure returns the value as the original DAS string */
OCerror
oc_inq_attrstrings(OCconnection conn, OCobject node0, unsigned int i,
char** namep, OCtype* octypep,
unsigned int* nvaluesp, char*** stringsp)
{
OCstate* state;
OCnode* node;
OCattribute* attr;
unsigned int nattrs;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
nattrs = oclistlength(node->attributes);
if(i >= nattrs) return OC_EINVAL;
attr = (OCattribute*)oclistget(node->attributes,i);
if(namep) *namep = strdup(attr->name);
if(octypep) *octypep = attr->etype;
if(nvaluesp) *nvaluesp = attr->nvalues;
if(stringsp) {
size_t space = attr->nvalues * sizeof(char*);
char** strings = (space > 0?ocmalloc(space):NULL);
for(i=0;i<attr->nvalues;i++)
strings[i] = nulldup(attr->values[i]);
*stringsp = strings;
}
return OC_NOERR;
}
/* Caller must free returned list */
OCerror
oc_inq_subnodes(OCconnection conn, OCobject node0, OCobject** subnodesp)
{
OCstate* state;
OCnode* node;
OCobject* subnodes = NULL;
unsigned int len;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
len = oclistlength(node->subnodes);
if(len > 0) {
unsigned int i;
subnodes = (OCobject*)occalloc(sizeof(OCobject),len+1);
for(i=0;i<len;i++) {
OCnode* ocnode = (OCnode*)oclistget(node->subnodes,i);
subnodes[i] = (OCobject)ocnode;
}
subnodes[len] = OCNULL; /* NULL terminate */
}
if(subnodesp) *subnodesp = subnodes;
return OC_NOERR;
}
static int
occompilefields(OCstate* state, OCnode* xnode, OCmemdata** memdatap, XDR* xdrs)
{
OCmemdata* structdata = NULL;
OCmemdata** qmem;
OCerror ocstat = OC_NOERR;
unsigned int i,nfields;
nfields = oclistlength(xnode->subnodes);
structdata = makememdata(OC_Structure,OC_NAT,nfields);
MEMCHECK(structdata,OC_ENOMEM);
qmem = (OCmemdata**)&structdata->data;
structdata->mode = Fieldmode;
for(i=0;i<nfields;i++) {
OCnode* field = (OCnode*)oclistget(xnode->subnodes,i);
OCmemdata* fielddata;
ocstat = occompile1(state,field,&fielddata,xdrs);
if(ocstat == OC_ENODATA) {
fielddata = NULL;
} else if(ocstat != OC_NOERR) {
freeocmemdata(structdata); return THROW(ocstat);
}
qmem[i] = fielddata;
}
if(memdatap) *memdatap = structdata;
return THROW(ocstat);
}
void
occlose(OCstate* state)
{
unsigned int i;
if(state == NULL) return;
/* Warning: ocfreeroot will attempt to remove the root from state->trees */
/* Ok in this case because we are popping the root out of state->trees */
for(i=0;i<oclistlength(state->trees);i++) {
OCnode* root = (OCnode*)oclistpop(state->trees);
ocfreeroot(root);
}
oclistfree(state->trees);
dapurlclear(&state->url);
ocbytesfree(state->packet);
ocfree(state->error.code);
ocfree(state->error.message);
if(state->contentlist != NULL) {
struct OCcontent* next;
struct OCcontent* curr = state->contentlist;
while(curr != NULL) {
next = curr->next;
ocfree(curr);
curr = next;
}
}
if(state->curl != NULL) occurlclose(state->curl);
if(state->clientparams != NULL) ocparamfree(state->clientparams);
ocfree(state);
}
static int
readfiletofile(const char* path, const char* suffix, FILE* stream, off_t* sizep)
{
int stat = OC_NOERR;
OCbytes* packet = ocbytesnew();
size_t len;
/* check for leading file:/// */
if(ocstrncmp(path,"file:///",8)==0) path += 7; /* assume absolute path*/
stat = readfile(path,suffix,packet);
#ifdef OCDEBUG
fprintf(stderr,"readfiletofile: packet.size=%lu\n",
(unsigned long)ocbyteslength(packet));
#endif
if(stat != OC_NOERR) goto unwind;
len = oclistlength(packet);
if(stat == OC_NOERR) {
size_t written;
fseek(stream,0,SEEK_SET);
written = fwrite(ocbytescontents(packet),1,len,stream);
if(written != len) {
#ifdef OCDEBUG
fprintf(stderr,"readfiletofile: written!=length: %lu :: %lu\n",
(unsigned long)written,(unsigned long)len);
#endif
stat = OC_EIO;
}
}
if(sizep != NULL) *sizep = len;
unwind:
ocbytesfree(packet);
return OCTHROW(stat);
}
int
oclistcontains(OClist* list, ocelem elem)
{
unsigned int i;
for(i=0;i<oclistlength(list);i++) {
if(elem == oclistget(list,i)) return 1;
}
return 0;
}
static void
setroot(OCnode* root, OClist* ocnodes)
{
int i;
for(i=0;i<oclistlength(ocnodes);i++) {
OCnode* node = (OCnode*)oclistget(ocnodes,i);
node->root = root;
}
}
OCerror
oc_inq_nattr(OCconnection conn, OCobject node0, unsigned int* nattrp)
{
OCstate* state;
OCnode* node;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
if(nattrp) {
if(node->octype == OC_Attribute) {
*nattrp = oclistlength(node->att.values);
} else {
*nattrp = oclistlength(node->attributes);
}
}
return OC_NOERR;
}
static void
addedges(OCnode* node)
{
unsigned int i;
if(node->subnodes == NULL) return;
for(i=0;i<oclistlength(node->subnodes);i++) {
OCnode* subnode = (OCnode*)oclistget(node->subnodes,i);
subnode->container = node;
}
}
static void
ocuncorrelate(OCnode* root)
{
OCtree* tree = root->tree;
unsigned int i;
if(tree == NULL) return;
for(i=0;i<oclistlength(tree->nodes);i++) {
OCnode* node = (OCnode*)oclistget(tree->nodes,i);
node->datadds = NULL;
}
}
void
ocparamfree(OClist* params)
{
int i;
if(params == NULL) return;
for(i=0;i<oclistlength(params);i++) {
char* s = (char*)oclistget(params,i);
if(s != NULL) free((void*)s);
}
oclistfree(params);
}
int
ocddsdasmerge(OCstate* state, OCnode* ddsroot, OCnode* dasroot)
{
int i,j;
int stat = OC_NOERR;
OClist* globals = oclistnew();
if(dasroot == NULL) return THROW(stat);
/* Start by looking for global attributes*/
for(i=0;i<oclistlength(dasroot->subnodes);i++) {
OCnode* node = (OCnode*)oclistget(dasroot->subnodes,i);
if(node->att.isglobal) {
for(j=0;j<oclistlength(node->subnodes);j++) {
OCnode* attnode = (OCnode*)oclistget(node->subnodes,j);
Attribute* att = makeattribute(attnode->name,
attnode->etype,
attnode->att.values);
oclistpush(globals,(ocelem)att);
}
}
}
ddsroot->attributes = globals;
/* Now try to match subnode names with attribute set names*/
for(i=0;i<oclistlength(dasroot->subnodes);i++) {
OCnode* das = (OCnode*)oclistget(dasroot->subnodes,i);
int match = 0;
if(das->att.isglobal) continue;
if(das->octype == OC_Attributeset) {
for(j=0;j<oclistlength(ddsroot->subnodes) && !match;j++) {
OCnode* dds = (OCnode*)oclistget(ddsroot->subnodes,j);
if(strcmp(das->name,dds->name) == 0) {
match = 1;
stat = mergedas1(dds,das);
if(stat != OC_NOERR) break;
}
}
}
if(!match) {marklostattribute(das);}
}
if(stat == OC_NOERR) ddsroot->attributed = 1;
return THROW(stat);
}
void
ocdumpclause(OCprojectionclause* ref)
{
unsigned int i;
OClist* path = oclistnew();
occollectpathtonode(ref->node,path);
for(i=0;i<oclistlength(path);i++) {
OClist* sliceset;
OCnode* node = (OCnode*)oclistget(path,i);
if(node->tree != NULL) continue; /* leave off the root node*/
fprintf(stdout,"%s%s",(i>0?PATHSEPARATOR:""),node->name);
sliceset = (OClist*)oclistget(ref->indexsets,i);
if(sliceset != NULL) {
unsigned int j;
for(j=0;j<oclistlength(sliceset);j++) {
OCslice* slice = (OCslice*)oclistget(sliceset,j);
ocdumpslice(slice);
}
}
}
}
void
computeocfullnames(OCnode* root)
{
unsigned int i;
if(root->name != NULL) computefullname(root);
if(root->subnodes != NULL) { /* recurse*/
for(i=0;i<oclistlength(root->subnodes);i++) {
OCnode* node = (OCnode*)oclistget(root->subnodes,i);
computeocfullnames(node);
}
}
}
/* Process ocnodes to fix various semantic issues*/
void
computeocsemantics(OClist* ocnodes)
{
unsigned int i;
OCASSERT((ocnodes != NULL));
for(i=0;i<oclistlength(ocnodes);i++) {
OCnode* node = (OCnode*)oclistget(ocnodes,i);
/* set the container for dims*/
if(node->octype == OC_Dimension && node->dim.array != NULL) {
node->container = node->dim.array->container;
}
}
}
void
makedimlist(OClist* path, OClist* dims)
{
unsigned int i,j;
for(i=0;i<oclistlength(path);i++) {
OCnode* node = (OCnode*)oclistget(path,i);
unsigned int rank = node->array.rank;
for(j=0;j<rank;j++) {
OCnode* dim = (OCnode*)oclistget(node->array.dimensions,j);
oclistpush(dims,(void*)dim);
}
}
}
OCerror
oc_inq_nsubnodes(OCconnection conn, OCobject node0, unsigned int* nsubnodesp)
{
OCstate* state;
OCnode* node;
OCVERIFY(OCstate*,state,conn);
OCDEREF(OCstate*,state,conn);
OCVERIFY(OCnode*,node,node0);
OCDEREF(OCnode*,node,node0);
if(nsubnodesp) *nsubnodesp = oclistlength(node->subnodes);
return OC_NOERR;
}
static void
ocassignall(OClist* list)
{
unsigned int i;
if(list != NULL)
for(i=0;i<oclistlength(list);i++) {
void* object = (void*)oclistget(list,i);
#ifdef TRACK
fprintf(stderr,"assign: %lu\n",(unsigned long)object); fflush(stderr);
#endif
oclistpush(ocmap,(ocelem)object);
}
}
size_t
ocfieldcount(OCstate* state, OCcontent* content)
{
OCnode* node = content->node;
size_t count;
OCASSERT((node != NULL));
count = oclistlength(node->subnodes);
/* If we are using memdata; then verify against the memdata */
if(content->memdata != NULL) {
OCASSERT(content->memdata->count == count);
}
return count;
}
