NMD
|
Go to the source code of this file.
#define CHECKHASNMDCOOKIE | ( | obj | ) | { if (!obj) NMD_ERR_REPORT("Null object"); if (((NMD_object)(obj))->cookie!=NMDCOOKIE) NMD_ERR_REPORTi("Object has invalid cookie",((NMD_object)(obj))->cookie); } |
Definition at line 39 of file nmd.h.
Referenced by NMDCategoryGetComponent(), NMDCategoryGetComponents(), NMDCategoryGetOrCreateComponent(), NMDCategoryTryGetComponent(), NMDCloneObject(), NMDCloneObjectStructure(), NMDComponentSetArrayValue(), NMDComponentSetValue(), NMDComponentUnsetValue(), NMDCopyArrayValue(), NMDCopyCategory(), NMDDestroyObject(), NMDGetArrayValue(), NMDGetCategories(), NMDGetCategoryIGetComponents(), NMDGetDataType(), NMDGetValue(), NMDObjectDumpToMySQL(), NMDObjectEnsureCategoryComponent(), NMDObjectGetCategory(), NMDObjectGetOrCreateCategory(), NMDObjectHasCategoryComponent(), NMDObjectTryGetCategory(), NMDRemoveCategory(), NMDReportObject(), NMDSetArrayValue(), NMDSetValue(), NMDStringAppend(), NMDStringConcat(), NMDStringDestroy(), NMDStringGetString(), NMDUnsetValue(), and NMDViewObject().
#define NMD_FREE | ( | a | ) | {free(a);} |
Definition at line 145 of file nmd.h.
Referenced by main(), NMDComponentDestroy(), NMDComponentUnsetValue(), NMDDestroyObject(), NMDRemoveCategory(), NMDReportObject(), and NMDStringDestroy().
#define NMD_MALLOC | ( | a, | |
b, | |||
c, | |||
d | |||
) |
{ a = (c*)malloc((b)*sizeof(c)); \ if (!a) NMD_ERR_REPORTs("Could not allocate",d); \ memset(a,0,(b)*sizeof(c)); }
Definition at line 141 of file nmd.h.
Referenced by main(), NMDAllocateCategory(), NMDAllocateComponent(), NMDCategoryGetComponents(), NMDComponentSetArrayValue(), NMDCopyArrayValue(), NMDCopyItemValues(), NMDCreateObject(), NMDGetCategories(), NMDGetCategoryIGetComponents(), NMDReportObject(), NMDStringCreateOfSize(), and NMDTabReportData().
#define NMD_STRDUP | ( | a, | |
b | |||
) | b = strdup(a); |
Definition at line 146 of file nmd.h.
Referenced by NMDCategoryAllocateNewComponent(), NMDComponentSetValue(), NMDCopyItemValues(), NMDObjectAllocateNewCategory(), and NMDRemoveCategory().
#define NMDCOOKIE 32897432 |
Definition at line 38 of file nmd.h.
Referenced by NMDAllocateCategory(), NMDAllocateComponent(), NMDCreateObject(), and NMDStringCreateOfSize().
#define NMDFalse 0 |
Definition at line 24 of file nmd.h.
Referenced by main(), NMDAllocateComponent(), NMDCategoryAllocateNewComponent(), NMDCategoryTryGetComponent(), NMDComponentUnsetValue(), NMDGetArrayValue(), NMDGetValue(), NMDIsArrayType(), NMDObjectEnsureCategoryComponent(), and NMDObjectTryGetCategory().
#define NMDTrue 1 |
Definition at line 23 of file nmd.h.
Referenced by main(), NMDCategoryTryGetComponent(), NMDComponentSetArrayValue(), NMDComponentSetValue(), NMDCopyArrayValue(), NMDGetArrayValue(), NMDGetValue(), NMDIsArrayType(), NMDObjectEnsureCategoryComponent(), and NMDObjectTryGetCategory().
typedef struct NMD_metadata_* NMD_metadata |
typedef struct NMD_metadata_category_* NMD_metadata_category |
typedef struct NMD_metadata_item_* NMD_metadata_item |
typedef struct NMD_object_* NMD_object |
typedef struct NMD_string_* NMD_string |
typedef int NMDErrorCode |
typedef double NMDRealtype |
enum NMDDataType |
NMDErrorCode NMDBuildObjectStructure | ( | NMD_metadata | ) |
NMDErrorCode NMDCategoryAllocateNewComponent | ( | NMD_metadata_category | cat, |
const char * | cmp, | ||
NMDDataType | type, | ||
NMD_metadata_item * | rcpt | ||
) |
Create a new component by name in an existing category object. If a component pointer is supplied, the new component object is returned, but this pointer is allowed to be NULL.
Definition at line 41 of file nmdcmp.c.
References NMD_metadata_category_::alloc, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_STRDUP, NMDAllocateComponent(), NMDFalse, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by main(), NMDCategoryGetOrCreateComponent(), and NMDObjectEnsureCategoryComponent().
{ NMD_metadata_item cpt; int idx; NMDErrorCode ierr; /* * if we are about to overflow, * reallocate the components in this category */ if (cat->ncmp >= cat->alloc) { NMD_metadata_item* newcmps; int newalloc; newalloc = 2*cat->alloc; ierr = PetscMalloc (newalloc*sizeof(struct NMD_metadata_item_),&newcmps); CHKERRQ(ierr); for (idx=0; idx<cat->ncmp; idx++) newcmps[idx] = cat->cmps[idx]; ierr = PetscFree(cat->cmps); CHKERRQ(ierr); cat->cmps = newcmps; cat->alloc = newalloc; } /* * with space guaranteed, create the component */ idx = cat->ncmp++; ierr = NMDAllocateComponent(&cpt); NMD_ERR_RETURN(ierr); NMD_STRDUP(cmp,cpt->name); cpt->t = type; cpt->set = NMDFalse; cat->cmps[idx] = cpt; if (rcpt) *rcpt = cpt; CHKMEMQ return 0; }
NMDErrorCode NMDCategoryCreateComponent | ( | NMD_metadata | , |
char * | , | ||
char * | |||
) |
NMDErrorCode NMDCategoryGetComponent | ( | NMD_metadata_category | cat, |
const char * | cmp, | ||
NMD_metadata_item * | cpt | ||
) |
Test whether a metadata category has a certain component. The component has to exist.
Definition at line 234 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, and NMDCategoryTryGetComponent().
Referenced by NMDGetArrayValue(), and NMDGetDataType().
{ NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(cat); ierr = NMDCategoryTryGetComponent (cat,cmp,cpt,&flg); NMD_ERR_RETURN(ierr); if (!flg) NMD_ERR_REPORTss("Could not find component in category",cmp,cat->name); CHKMEMQ return 0; }
NMDErrorCode NMDCategoryGetComponents | ( | NMD_metadata | obj, |
const char * | cat, | ||
int * | ncmp, | ||
const char *** | cmps, | ||
NMDDataType ** | typs | ||
) |
Get a list of all component names and types in a category. All three output arguments are optional. The names and types arrays are allocated and should be freed by the user by NMD_FREE(). The names in the name array points to the strings in the database object, so they do not need to be freed.
Definition at line 205 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_MALLOC, NMDObjectGetCategory(), and NMD_metadata_item_::t.
Referenced by main().
{ NMD_metadata_category catobj; int icmp; const char **names; NMDDataType *types; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetCategory(obj,cat,&catobj); CHKERRQ(ierr); if (ncmp) *ncmp = catobj->ncmp; if (cmps) { NMD_MALLOC(names,catobj->ncmp,char*,"name array"); for (icmp=0; icmp<catobj->ncmp; icmp++) names[icmp] = catobj->cmps[icmp]->name; *cmps = names; } if (typs) { NMD_MALLOC(types,catobj->ncmp,NMDDataType,"type array"); for (icmp=0; icmp<catobj->ncmp; icmp++) types[icmp] = catobj->cmps[icmp]->t; *typs = types; } CHKMEMQ return 0; }
NMDErrorCode NMDCategoryGetOrCreateComponent | ( | NMD_metadata_category | cat, |
const char * | cmp, | ||
NMDDataType | type, | ||
NMD_metadata_item * | cpt | ||
) |
Retrieve a component, creating it if it doesn't already exist.
Definition at line 108 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryAllocateNewComponent(), NMDCategoryTryGetComponent(), and NMD_metadata_item_::t.
Referenced by main(), NMDCloneObject(), NMDCopyArrayValue(), NMDCopyCategory(), NMDSetArrayValue(), and NMDSetValue().
{ NMD_metadata_item cnew; NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(cat); ierr = NMDCategoryTryGetComponent(cat,cmp,&cnew,&flg); NMD_ERR_RETURN(ierr); if (flg) { if (type!=cnew->t) NMD_ERR_REPORTii ("Type incompatibility: old/new",(int)(cnew->t),(int)type); if (cpt) *cpt = cnew; } else { ierr = NMDCategoryAllocateNewComponent (cat,cmp,type,cpt); NMD_ERR_RETURN(ierr); } CHKMEMQ return 0; }
NMDErrorCode NMDCategoryTryGetComponent | ( | NMD_metadata_category | cat, |
const char * | cmp, | ||
NMD_metadata_item * | rcpt, | ||
NMDTruth * | f | ||
) |
Test whether a metadata category has a certain component.
Definition at line 178 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMDFalse, and NMDTrue.
Referenced by main(), NMDCategoryGetComponent(), NMDCategoryGetOrCreateComponent(), NMDGetValue(), NMDObjectEnsureCategoryComponent(), NMDObjectHasCategoryComponent(), and NMDUnsetValue().
{ int icmp; CHECKHASNMDCOOKIE(cat); *f = NMDFalse; for (icmp=0; icmp<cat->ncmp; icmp++) { NMD_metadata_item cpt = cat->cmps[icmp]; CHECKHASNMDCOOKIE(cpt); if (strcmp(cmp,cpt->name)==0) { *f = NMDTrue; if (rcpt) *rcpt = cpt; break; } } CHKMEMQ return 0; }
NMDErrorCode NMDCloneObject | ( | NMD_metadata | old, |
NMD_metadata | nnew | ||
) |
Given an already created NMD_metadata object, fill it with the data of a template object. See also NMDCloneObjectStructure().
Definition at line 210 of file nmd.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDCategoryGetOrCreateComponent(), NMDCopyItemValues(), NMDObjectGetOrCreateCategory(), and NMD_metadata_item_::t.
Referenced by main().
{ int icat; NMDErrorCode ierr; CHECKHASNMDCOOKIE(old); CHECKHASNMDCOOKIE(nnew); for (icat=0; icat<old->ncat; icat++) { /* loop over input categories by index; output categories are retrieved by label, or newly created */ NMD_metadata_category oldcat = old->cats[icat],newcat; int icmp; ierr = NMDObjectGetOrCreateCategory (nnew,oldcat->name,&newcat); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(oldcat); for (icmp=0; icmp<oldcat->ncmp; icmp++) { NMD_metadata_item oldcmp = oldcat->cmps[icmp],newcmp; ierr = NMDCategoryGetOrCreateComponent (newcat,oldcmp->name,oldcmp->t,&newcmp); NMD_ERR_RETURN(ierr); ierr = NMDCopyItemValues(oldcmp,newcmp); NMD_ERR_RETURN(ierr); } } CHKMEMQ return 0; }
NMDErrorCode NMDCloneObjectStructure | ( | NMD_metadata | old, |
NMD_metadata * | ret | ||
) |
This routine creates an NMD_metadata object, and fills it in with the categories and components of a template object. Data is not copied; for that, see NMDCloneObject() and NMDCopyCategory().
Definition at line 181 of file nmd.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDCreateObject(), NMDObjectEnsureCategoryComponent(), and NMD_metadata_item_::t.
Referenced by main().
{ NMD_metadata nnew; int icat,icmp; NMDErrorCode ierr; CHECKHASNMDCOOKIE(old); ierr = NMDCreateObject(&nnew); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(nnew); for (icat=0; icat<old->ncat; icat++) { NMD_metadata_category oldcat = old->cats[icat]; CHECKHASNMDCOOKIE(oldcat); for (icmp=0; icmp<oldcat->ncmp; icmp++) { NMD_metadata_item oldcmp = oldcat->cmps[icmp]; CHECKHASNMDCOOKIE(oldcmp); ierr = NMDObjectEnsureCategoryComponent (nnew,oldcat->name,oldcmp->name,oldcmp->t,NULL); NMD_ERR_RETURN(ierr); } } CHKMEMQ *ret = nnew; return 0; }
NMDErrorCode NMDComponentDestroy | ( | NMD_metadata_item | ) |
Definition at line 72 of file nmdcmp.c.
References NMD_metadata_item_::cc, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMD_metadata_item_::name, NMD_FREE, NMDIntarray, NMDRealarray, NMDString, NMD_metadata_item_::rr, NMD_metadata_item_::t, NMD_realarray_struct::unique, and NMD_intarray_struct::unique.
Referenced by NMDDestroyObject().
{ switch (cmp->t) { case NMDIntarray : if (cmp->ii) { struct NMD_intarray_struct *arraystruct = (struct NMD_intarray_struct *)(cmp->ii); if (arraystruct->length>0 && arraystruct->unique==1) NMD_FREE(arraystruct->data); NMD_FREE(cmp->ii); } ; break; case NMDRealarray : if (cmp->rr) { struct NMD_realarray_struct *arraystruct = (struct NMD_realarray_struct *)(cmp->rr); if (arraystruct->length>0 && arraystruct->unique==1) NMD_FREE(arraystruct->data); NMD_FREE(cmp->rr); } ; break; case NMDString : NMD_FREE(cmp->cc); break; default : /* other components need no destructor */ break; } NMD_FREE(cmp->name); NMD_FREE(cmp); return 0; }
NMDErrorCode NMDComponentSetArrayValue | ( | NMD_metadata_item | , |
NMDDataType | , | ||
void * | , | ||
int | |||
) |
Definition at line 323 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMD_MALLOC, NMDComponentSetValue(), NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::rr, NMD_metadata_item_::set, NMD_metadata_item_::t, NMD_realarray_struct::unique, and NMD_intarray_struct::unique.
Referenced by NMDSetArrayValue().
{ NMDErrorCode ierr; CHECKHASNMDCOOKIE(cpt); switch (cpt->t) { case NMDInt : case NMDReal : case NMDString : ierr = NMDComponentSetValue(cpt,cpt->t,v); NMD_ERR_RETURN(ierr); break; case NMDIntarray : { struct NMD_intarray_struct* iistruct; NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct"); iistruct->unique = 0; iistruct->length = l; iistruct->data = *(int**)v; cpt->ii = iistruct; break;} case NMDRealarray : { struct NMD_realarray_struct* rrstruct; NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct"); rrstruct->unique = 0; rrstruct->length = l; rrstruct->data = *(NMDRealtype**)v; cpt->rr = rrstruct; break;} default : NMD_ERR_REPORTi("Unknown type",(int)t) } cpt->set = NMDTrue; return 0; }
NMDErrorCode NMDComponentSetValue | ( | NMD_metadata_item | , |
NMDDataType | , | ||
void * | |||
) |
Definition at line 278 of file nmdcmp.c.
References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, NMD_metadata_item_::i, NMD_STRDUP, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by NMDComponentSetArrayValue(), and NMDSetValue().
{ CHECKHASNMDCOOKIE(cpt); if (t!=cpt->t) NMD_ERR_REPORT("Type conflict"); switch (cpt->t) { case NMDInt : cpt->i = *(int*)v; break; case NMDReal : cpt->r = *(double*)v; break; case NMDString : NMD_STRDUP((char*)v,cpt->cc); break; case NMDIntarray : case NMDRealarray : NMD_ERR_REPORT("Please use NMDSetArrayValue"); break; default : NMD_ERR_REPORTi("Unknown type",(int)t); break; } cpt->set = NMDTrue; return 0; }
NMDErrorCode NMDComponentUnsetValue | ( | NMD_metadata_item | ) |
Definition at line 297 of file nmdcmp.c.
References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::ii, NMD_FREE, NMDFalse, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by NMDUnsetValue().
{ CHECKHASNMDCOOKIE(cpt); switch (cpt->t) { case NMDInt : case NMDReal : break; case NMDString : NMD_FREE(cpt->cc); break; case NMDIntarray : { struct NMD_intarray_struct* iistruct = cpt->ii; NMD_FREE(iistruct->data); NMD_FREE(iistruct); break;} case NMDRealarray : { struct NMD_realarray_struct* rrstruct = cpt->rr; NMD_FREE(rrstruct->data); NMD_FREE(rrstruct); break;} default : NMD_ERR_REPORTi("Unknown type",cpt->t); break; } cpt->set = NMDFalse; return 0; }
NMDErrorCode NMDCopyArrayValue | ( | NMD_metadata | obj, |
const char * | cat, | ||
const char * | cmp, | ||
NMDDataType | t, | ||
void * | v, | ||
int | l | ||
) |
Set a metadata array value; the user array is copied.
This call can be used to create categories and components; there is no checking of slight misspellings.
See also Value handling.
Definition at line 518 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMD_MALLOC, NMDCategoryGetOrCreateComponent(), NMDInt, NMDIntarray, NMDObjectGetOrCreateCategory(), NMDReal, NMDRealarray, NMDSetValue(), NMDString, NMDTrue, NMD_metadata_item_::rr, NMD_metadata_item_::set, NMD_metadata_item_::t, NMD_realarray_struct::unique, and NMD_intarray_struct::unique.
Referenced by main().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(cpt); cpt->set = NMDTrue; switch (cpt->t) { case NMDInt : case NMDReal : case NMDString : ierr = NMDSetValue(obj,cat,cmp,t,v); NMD_ERR_RETURN(ierr); break; case NMDIntarray : { struct NMD_intarray_struct* iistruct; int *ii,i; NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct"); iistruct->unique = 1; iistruct->length = l; NMD_MALLOC(ii,l,sizeof(int),"copied int array"); for (i=0; i<l; i++) ii[i] = (*(int**)v)[i]; iistruct->data = ii; cpt->ii = iistruct; break;} case NMDRealarray : { struct NMD_realarray_struct* rrstruct; NMDRealtype *rr; int i; NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct"); rrstruct->unique = 1; rrstruct->length = l; NMD_MALLOC(rr,l,NMDRealtype,"copied real array"); for (i=0; i<l; i++) rr[i] = (*(NMDRealtype**)v)[i]; rrstruct->data = rr; cpt->rr = rrstruct; break;} default : NMD_ERR_REPORTi("Unknown type",(int)t); break; } CHKMEMQ return 0; }
NMDErrorCode NMDCopyCategory | ( | NMD_metadata_category | incat, |
NMD_metadata_category | outcat | ||
) |
Copy category data from one metadata structure into another. This assumes that the category already exists in the target; see for instance NMDHasCategory(), NMDCloneObject(), NMDCloneObjectStructure().
Definition at line 180 of file nmdcat.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMDCategoryGetOrCreateComponent(), NMDCopyItemValues(), and NMD_metadata_item_::t.
{ int icmp; NMDErrorCode ierr; CHECKHASNMDCOOKIE(incat); CHECKHASNMDCOOKIE(outcat); for (icmp=0; icmp<incat->ncmp; icmp++) { NMD_metadata_item src = incat->cmps[icmp],tar; ierr = NMDCategoryGetOrCreateComponent (outcat,src->name,src->t,&tar); NMD_ERR_RETURN(ierr); ierr = NMDCopyItemValues(src,tar); NMD_ERR_RETURN(ierr); } CHKMEMQ return 0; }
NMDErrorCode NMDCopyItemValues | ( | NMD_metadata_item | src, |
NMD_metadata_item | tar | ||
) |
Copy data between two item structures. If the original has unique data, so does the clone.
Definition at line 359 of file nmdcmp.c.
References NMD_metadata_item_::cc, CHKMEMQ, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::i, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMD_MALLOC, NMD_STRDUP, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMD_metadata_item_::r, NMD_metadata_item_::rr, NMD_metadata_item_::set, NMD_metadata_item_::t, NMD_realarray_struct::unique, and NMD_intarray_struct::unique.
Referenced by NMDCloneObject(), and NMDCopyCategory().
{ tar->set = src->set; if (!src->set) goto done; switch (src->t) { case NMDInt : tar->i = src->i; break; case NMDReal : tar->r = src->r ; break; case NMDString : NMD_STRDUP(src->cc,tar->cc); break; case NMDIntarray : { struct NMD_intarray_struct *tarstruct,*srcstruct = src->ii; int length=srcstruct->length; NMD_MALLOC(tarstruct,1,struct NMD_intarray_struct,"copied int array"); tarstruct->length = length; tarstruct->unique = srcstruct->unique; if (srcstruct->unique) { int *a1=srcstruct->data,*a2; int i; NMD_MALLOC(a2,length,int,"int array data"); for (i=0; i<length; i++) a2[i] = a1[i]; tarstruct->data = a2; } else tarstruct->data = srcstruct->data; tar->ii = tarstruct; } ; break; case NMDRealarray : { struct NMD_realarray_struct *tarstruct,*srcstruct = src->rr; int length=srcstruct->length; NMD_MALLOC(tarstruct,1,struct NMD_realarray_struct,"copied real array"); tarstruct->length = length; tarstruct->unique = srcstruct->unique; if (srcstruct->unique) { NMDRealtype *a1=srcstruct->data,*a2; int i; NMD_MALLOC(a2,length,NMDRealtype,"real array data"); for (i=0; i<length; i++) a2[i] = a1[i]; tarstruct->data = a2; } else tarstruct->data = srcstruct->data; tar->rr = tarstruct; } ; break; default : NMD_ERR_REPORTi("Can not copy items of type",(int)(src->t)); break; } done: CHKMEMQ return 0; }
NMDErrorCode NMDCreateObject | ( | NMD_metadata * | obj | ) |
This routine create an NMD_metadata object, and allocates enough space in it for 10 categories of 20 elements each. Currently this can not be reallocated. In the future we want to be a bit more flexible.
Definition at line 108 of file nmd.c.
References NMD_metadata_::alloc, CATCHUNK, NMD_metadata_::cats, CHKMEMQ, NMD_metadata_::cookie, NMD_metadata_::ncat, NMD_MALLOC, and NMDCOOKIE.
Referenced by main(), and NMDCloneObjectStructure().
{ NMD_metadata nnew; /* allocate the metadata object */ NMD_MALLOC(nnew,1,struct NMD_metadata_,"object"); nnew->cookie = NMDCOOKIE; *obj = nnew; /* give it a basic array of categories */ nnew->alloc = CATCHUNK; nnew->ncat = 0; NMD_MALLOC(nnew->cats,nnew->alloc,NMD_metadata_category,"categories"); CHKMEMQ return 0; }
NMDErrorCode NMDDestroyObject | ( | NMD_metadata | obj | ) |
Deallocate all the data in a metadata object.
Definition at line 130 of file nmd.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMD_FREE, and NMDComponentDestroy().
Referenced by main().
{ int i,j; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); for (i=0; i<obj->ncat; i++) { NMD_metadata_category cat = obj->cats[i]; for (j=0; j<cat->ncmp; j++) { NMD_metadata_item cmp = cat->cmps[j]; ierr = NMDComponentDestroy(cmp); NMD_ERR_RETURN(ierr); } NMD_FREE(cat->cmps); NMD_FREE(cat->name); NMD_FREE(cat); CHKMEMQ } NMD_FREE(obj->cats); NMD_FREE(obj); return 0; }
NMDErrorCode NMDDestroyObjectStructure | ( | NMD_metadata | ) |
NMDErrorCode NMDGetArrayValue | ( | NMD_metadata | obj, |
const char * | cat, | ||
const char * | cmp, | ||
NMDDataType * | t, | ||
void * | v, | ||
int * | len, | ||
NMDTruth * | f | ||
) |
Retrieve a stored value. If no value has been stored under the specified category and component, a zero flag is returned. The flag parameter can be null.
Null pointers can be passed for the datatype or value, for instance to test only for the existence of a set value.
See also Value handling.
Definition at line 632 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMDCategoryGetComponent(), NMDFalse, NMDGetValue(), NMDInt, NMDIntarray, NMDObjectGetCategory(), NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by main().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(ctg); ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(cpt); if (!cpt->set) { if (f) { *f = NMDFalse; return 0; } else NMD_ERR_REPORT ("Value not set, but no flag given to report this"); } if (t) *t = cpt->t; switch (cpt->t) { case NMDInt : case NMDReal : case NMDString : ierr = NMDGetValue(obj,cat,cmp,NULL,v,f); NMD_ERR_RETURN(ierr); break; case NMDIntarray : if (v || len) { struct NMD_intarray_struct *as = cpt->ii; if (v) *(int**)v = as->data; if (len) *len = as->length; } if (f) *f = NMDTrue; break; case NMDRealarray : if (v || len) { struct NMD_realarray_struct *as = cpt->rr; if (v) *(NMDRealtype**)v = as->data; if (len) *len = as->length; } if (f) *f = NMDTrue; break; default : if (f) *f = NMDFalse; } CHKMEMQ return 0; }
NMDErrorCode NMDGetCategories | ( | NMD_metadata | obj, |
int * | ncat, | ||
char *** | cats | ||
) |
Get the number of categories and their names. Both arguments can be NULL. The names array is allocated; the user needs to free it. The names themselves are pointers to the strings in the metadata object, so they do not need to be freed.
Definition at line 137 of file nmdcat.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, NMD_metadata_::ncat, and NMD_MALLOC.
Referenced by main(), and NMDTabReportData().
{ CHECKHASNMDCOOKIE(obj); if (ncat) *ncat = obj->ncat; if (obj->ncat && cats) { char **names; int icat; NMD_MALLOC(names,obj->ncat,char*,"name array"); for (icat=0; icat<obj->ncat; icat++) names[icat] = obj->cats[icat]->name; *cats = names; } CHKMEMQ return 0; }
NMDErrorCode NMDGetCategoryIGetComponents | ( | NMD_metadata | obj, |
int | icat, | ||
int * | ncmp, | ||
char *** | cmps, | ||
NMDDataType ** | typs | ||
) |
For a given category, get the number of components and their names.
All output arguments can be NULL. The names array is allocated; the user needs to free it. The names themselves are pointers to the strings in the metadata object, so they do not need to be freed. The types array is also allocated and needs to be freed.
Definition at line 255 of file nmdcmp.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_MALLOC, and NMD_metadata_item_::t.
{ NMD_metadata_category cat; CHECKHASNMDCOOKIE(obj); cat = obj->cats[icat]; if (ncmp) *ncmp = cat->ncmp; if (cat->ncmp && (cmps || typs) ) { NMDDataType *types; char **names; int icmp; if (cmps) NMD_MALLOC(names,cat->ncmp,char*,"name array"); if (typs) NMD_MALLOC(types,cat->ncmp,NMDDataType,"name array"); for (icmp=0; icmp<cat->ncmp; icmp++) { if (cmps) names[icmp] = cat->cmps[icmp]->name; if (typs) types[icmp] = cat->cmps[icmp]->t; } if (cmps) *cmps = names; if (typs) *typs = types; } return 0; }
NMDErrorCode NMDGetDataType | ( | NMD_metadata | , |
const char * | , | ||
const char * | , | ||
NMDDataType * | t | ||
) |
Definition at line 720 of file nmd.c.
References CHECKHASNMDCOOKIE, NMDCategoryGetComponent(), NMDObjectGetCategory(), and NMD_metadata_item_::t.
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr); CHECKHASNMDCOOKIE(cmp); *t = cpt->t; return 0; }
NMDErrorCode NMDGetTypeMySQLName | ( | NMDDataType | , |
const char ** | |||
) |
Definition at line 745 of file nmd.c.
References mysqltypenames, and nnmdtypenames.
Referenced by main().
{ int itype = (int)(type); if (itype<0 || itype>=nnmdtypenames) NMD_ERR_REPORTi("Invalid type",itype); *name = (char*)mysqltypenames[itype]; return 0; }
NMDErrorCode NMDGetValue | ( | NMD_metadata | obj, |
const char * | cat, | ||
const char * | cmp, | ||
NMDDataType * | t, | ||
void * | v, | ||
NMDTruth * | f | ||
) |
Retrieve a stored scalar value. If no value has been stored under the specified category and component, a zero flag is returned. The flag parameter can be null.
Null pointers can be passed for the datatype or value, for instance to test only for the existence of a set value.
See also Value handling.
Definition at line 571 of file nmd.c.
References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_item_::i, NMDCategoryTryGetComponent(), NMDFalse, NMDInt, NMDIntarray, NMDObjectTryGetCategory(), NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by main(), NMDGetArrayValue(), and NMDTabReportData().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDTruth ff; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&ff); NMD_ERR_RETURN(ierr); if (!ff) { if (f) { *f = NMDFalse; return 0; } else NMD_ERR_REPORT ("Could not find category, but no flag given to report this"); } CHECKHASNMDCOOKIE(ctg); ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&ff); NMD_ERR_RETURN(ierr); if (!ff) { if (f) { *f = NMDFalse; return 0; } else NMD_ERR_REPORT ("Could not find component, but no flag given to report this"); } CHECKHASNMDCOOKIE(cpt); if (!cpt->set) { if (f) { *f = NMDFalse; return 0; } else NMD_ERR_REPORT ("Value not set, but no flag given to report this"); } if (t) *t = cpt->t; switch (cpt->t) { case NMDInt : if (v) *(int*)v = cpt->i; if (f) *f = NMDTrue; break; case NMDReal : if (v) *(double*)v = cpt->r; if (f) *f = NMDTrue; break; case NMDString : if (v) *(char**)v = cpt->cc; if (f) *f = NMDTrue; break; case NMDIntarray : case NMDRealarray : NMD_ERR_REPORT("Please use NMDGetArrayValue"); break; default : if (f) *f = NMDFalse; } CHKMEMQ return 0; }
NMDErrorCode NMDIsArrayType | ( | NMDDataType | type, |
NMDTruth * | flg | ||
) |
Test whether a data type is an array type
Definition at line 737 of file nmd.c.
References NMDFalse, NMDIntarray, NMDRealarray, and NMDTrue.
Referenced by main().
{ *flg = ( (type==NMDIntarray) || (type==NMDRealarray) ? NMDTrue : NMDFalse ) ; return 0; }
NMDErrorCode NMDObjectAllocateNewCategory | ( | NMD_metadata | obj, |
const char * | cat, | ||
NMD_metadata_category * | rctg | ||
) |
Allocate a category in a metadata object. There is no testing whether the category name is already in use.
If a category pointer is supplied, the category is returned, but this pointer is allowed to be null.
Definition at line 84 of file nmdcat.c.
References NMD_metadata_::alloc, NMD_metadata_::cats, CHKMEMQ, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_STRDUP, and NMDAllocateCategory().
Referenced by main(), NMDObjectEnsureCategoryComponent(), and NMDObjectGetOrCreateCategory().
{ NMD_metadata_category ctg; int idx; NMDErrorCode ierr; /* * if we are about to overflow, reallocate */ if (obj->ncat >= obj->alloc) { NMD_metadata_category* newcats; int newalloc; newalloc = 2*obj->alloc; ierr = PetscMalloc (newalloc*sizeof(struct NMD_metadata_category_),&newcats); CHKERRQ(ierr); for (idx=0; idx<obj->ncat; idx++) newcats[idx] = obj->cats[idx]; ierr = PetscFree(obj->cats); CHKERRQ(ierr); obj->cats = newcats; obj->alloc = newalloc; } /* * with space guaranteed, create the category */ idx = obj->ncat++; ierr = NMDAllocateCategory(&ctg); NMD_ERR_RETURN(ierr); NMD_STRDUP(cat,ctg->name); obj->cats[idx] = ctg; if (rctg) *rctg = ctg; CHKMEMQ return 0; }
NMDErrorCode NMDObjectDumpToMySQL | ( | NMD_metadata | obj | ) |
Generate an mysql dump of an object
Definition at line 11 of file nmdmysql.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, NMD_metadata_category_::cmps, NMD_metadata_item_::i, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDInt, NMDReal, NMDStringAppend(), NMDStringConcat(), NMDStringCreate(), NMDStringDestroy(), NMDStringGetString(), NMD_metadata_item_::r, and NMD_metadata_item_::t.
{ NMD_string namesstring,valuesstring; int icat,icmp; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDStringCreate("",&namesstring); NMD_ERR_RETURN(ierr); ierr = NMDStringCreate("",&valuesstring); NMD_ERR_RETURN(ierr); for (icat=0; icat<obj->ncat; icat++) { NMD_metadata_category cat = obj->cats[icat]; NMD_string catstring; CHECKHASNMDCOOKIE(cat); ierr = NMDStringCreate(cat->name,&catstring); NMD_ERR_RETURN(ierr); for (icmp=0; icmp<cat->ncmp; icmp++) { char cmpvalue[45]; NMD_metadata_item cmp = cat->cmps[icmp]; CHECKHASNMDCOOKIE(cmp); memset(cmpvalue,0,45); switch (cmp->t) { case NMDInt : sprintf(cmpvalue,"%d",cmp->i); break; case NMDReal : sprintf(cmpvalue,"%e",cmp->r); break; default : continue; } if (cmpvalue[0]) { NMD_string cmpstring,cmpcatstring; /* name */ ierr = NMDStringCreate(cmp->name,&cmpstring); NMD_ERR_RETURN(ierr); ierr = NMDStringConcat (0,catstring,':',cmpstring,0,&cmpcatstring); NMD_ERR_RETURN(ierr); ierr = NMDStringAppend (0,&namesstring,0,cmpcatstring,','); NMD_ERR_RETURN(ierr); ierr = NMDStringDestroy(cmpstring); NMD_ERR_RETURN(ierr); ierr = NMDStringDestroy(cmpcatstring); NMD_ERR_RETURN(ierr); /* value */ ierr = NMDStringCreate(cmpvalue,&cmpcatstring); NMD_ERR_RETURN(ierr); ierr = NMDStringAppend (0,&valuesstring,0,cmpcatstring,','); NMD_ERR_RETURN(ierr); ierr = NMDStringDestroy(cmpcatstring); NMD_ERR_RETURN(ierr); } } ierr = NMDStringDestroy(catstring); NMD_ERR_RETURN(ierr); } { const char *c; ierr = NMDStringGetString(namesstring,&c); NMD_ERR_RETURN(ierr); printf("INSERT INTO yourtable (%s)\n",c); ierr = NMDStringGetString(valuesstring,&c); NMD_ERR_RETURN(ierr); printf("VALUES (%s);\n",c); } return 0; }
NMDErrorCode NMDObjectEnsureCategoryComponent | ( | NMD_metadata | , |
const char * | , | ||
const char * | , | ||
NMDDataType | , | ||
NMDTruth * | |||
) |
Definition at line 134 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryAllocateNewComponent(), NMDCategoryTryGetComponent(), NMDFalse, NMDObjectAllocateNewCategory(), NMDObjectTryGetCategory(), NMDTrue, and NMD_metadata_item_::t.
Referenced by main(), and NMDCloneObjectStructure().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr); if (!flg) { ierr = NMDObjectAllocateNewCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); } ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr); if (flg) { if (nnew) *nnew = NMDFalse; if (type!=cpt->t) NMD_ERR_REPORTii ("Type incompatibility: old/new",(int)(cpt->t),(int)type); } else { if (nnew) *nnew = NMDTrue; ierr = NMDCategoryAllocateNewComponent (ctg,cmp,type,NULL); NMD_ERR_RETURN(ierr); } CHKMEMQ return 0; }
NMDErrorCode NMDObjectGetCategory | ( | NMD_metadata | obj, |
const char * | cat, | ||
NMD_metadata_category * | ctg | ||
) |
Retrieve a category from a metadata object. The category has to exist.
Definition at line 49 of file nmdcat.c.
References CHECKHASNMDCOOKIE, and NMDObjectTryGetCategory().
Referenced by NMDCategoryGetComponents(), NMDGetArrayValue(), NMDGetDataType(), and NMDRemoveCategory().
{ NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr); if (!flg) NMD_ERR_REPORTs("Category not found",cat); return 0; }
NMDErrorCode NMDObjectGetOrCreateCategory | ( | NMD_metadata | obj, |
const char * | cat, | ||
NMD_metadata_category * | ctg | ||
) |
Retrieve a category from a metadata object, or create it if it doesn't exist yet.
Definition at line 118 of file nmdcat.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDObjectAllocateNewCategory(), and NMDObjectTryGetCategory().
Referenced by NMDCloneObject(), NMDCopyArrayValue(), NMDSetArrayValue(), and NMDSetValue().
{ NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr); if (!flg) { ierr = NMDObjectAllocateNewCategory(obj,cat,ctg); NMD_ERR_RETURN(ierr); } CHKMEMQ return 0; }
NMDErrorCode NMDObjectHasCategoryComponent | ( | NMD_metadata | , |
const char * | , | ||
const char * | , | ||
NMDTruth * | |||
) |
Definition at line 161 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), and NMDObjectTryGetCategory().
Referenced by main().
{ NMD_metadata_category ctg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,&ctg,f); NMD_ERR_RETURN(ierr); if (*f) { ierr = NMDCategoryTryGetComponent(ctg,cmp,NULL,f); NMD_ERR_RETURN(ierr); } CHKMEMQ return 0; }
NMDErrorCode NMDObjectTryGetCategory | ( | NMD_metadata | obj, |
const char * | cat, | ||
NMD_metadata_category * | rctg, | ||
NMDTruth * | f | ||
) |
Test whether a metadata object has a certain category, if so yield up its pointer.
The category pointer parameter can be null, in which case only existence is tested.
Definition at line 29 of file nmdcat.c.
References NMD_metadata_::cats, CHECKHASNMDCOOKIE, NMD_metadata_category_::name, NMD_metadata_::ncat, NMDFalse, and NMDTrue.
Referenced by main(), NMDGetValue(), NMDObjectEnsureCategoryComponent(), NMDObjectGetCategory(), NMDObjectGetOrCreateCategory(), NMDObjectHasCategoryComponent(), and NMDUnsetValue().
{ int icat; CHECKHASNMDCOOKIE(obj); *f = NMDFalse; for (icat=0; icat<obj->ncat; icat++) { NMD_metadata_category ctg = obj->cats[icat]; CHECKHASNMDCOOKIE(ctg); if (strcmp(cat,ctg->name)==0) { if (rctg) *rctg = ctg; *f = NMDTrue; break; } } return 0; }
NMDErrorCode NMDRemoveCategory | ( | NMD_metadata | , |
const char * | |||
) |
Definition at line 160 of file nmdcat.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, NMD_FREE, NMD_STRDUP, and NMDObjectGetCategory().
Referenced by main().
{ NMD_metadata_category ctg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); NMD_FREE(ctg->name); NMD_STRDUP("invalid",ctg->name); CHKMEMQ return 0; }
NMDErrorCode NMDReportObject | ( | NMD_metadata | obj, |
NMDTruth | arrays, | ||
const char ** | rkey, | ||
const char ** | rval, | ||
const char | delim, | ||
const char | itemdelim1, | ||
const char | itemdelim2 | ||
) |
Generate a delimited representation of a metadata object.
The returned strings are allocated in this routine and it is the user's responsibility to free them with NMD_FREE().
Arguments:
rkey
and rval
Definition at line 297 of file nmd.c.
References NMD_metadata_::cats, NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, CHKLEN, CHKMEMQ, CHKSPACEFOR, NMD_metadata_category_::cmps, NMD_realarray_struct::data, NMD_intarray_struct::data, NMD_metadata_item_::i, NMD_metadata_item_::ii, NMD_realarray_struct::length, NMD_intarray_struct::length, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMD_FREE, NMD_MALLOC, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMD_metadata_item_::r, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.
Referenced by main().
{ int icat,icmp,write,keylen=0,vallen=0; char *key=NULL,*val=NULL, *scratch; CHECKHASNMDCOOKIE(obj); /* * allocate and fill in the key and value strings */ #define CHKLEN 500 NMD_MALLOC(scratch,CHKLEN,char,"scratch pad"); #define CHKSPACEFOR(ar,arlen,fmt,str) {int nr; memset(scratch,0,CHKLEN); sprintf(scratch,fmt,str); nr=strlen(scratch); if (write==0) {arlen = arlen+nr+2; } else {int l = strlen(ar); if (l+nr<arlen) {sprintf(ar+l,fmt,str);} else SETERRQ(1,"sprintf would overflow allocated buffer");}} write = 0; writeloop: if (write==0) { keylen=vallen=0; } else { if (rkey) NMD_MALLOC(key,keylen,char,"names array"); if (rval) NMD_MALLOC(val,vallen,char,"values array"); } for (icat=0; icat<obj->ncat; icat++) { NMD_metadata_category cat = obj->cats[icat]; CHECKHASNMDCOOKIE(cat); for (icmp=0; icmp<cat->ncmp; icmp++) { NMD_metadata_item cmp = cat->cmps[icmp]; CHECKHASNMDCOOKIE(cmp); if (rkey) { if (itemdelim1) CHKSPACEFOR(key,keylen,"%c",itemdelim1); CHKSPACEFOR(key,keylen,"%s:",cat->name); CHKSPACEFOR(key,keylen,"%s",cmp->name); if (itemdelim2) CHKSPACEFOR(key,keylen,"%c",itemdelim2); CHKSPACEFOR(key,keylen,"%c",delim); } if (rval) { if (itemdelim1) CHKSPACEFOR(val,vallen,"%c",itemdelim1); if (!cmp->set) goto delimiter; switch (cmp->t) { case NMDInt : { CHKSPACEFOR(val,vallen,"%8d",cmp->i); break;} case NMDReal : { CHKSPACEFOR(val,vallen,"%15.8e",cmp->r); break;} case NMDString : if (!cmp->cc) NMD_ERR_REPORT("Null string"); if (strlen(cmp->cc)>0) { if (strlen(cmp->cc)<=CHKLEN) { CHKSPACEFOR(val,vallen,"%s",cmp->cc); } else {CHKSPACEFOR(val,vallen,"%s","stringtoolong");} } else { CHKSPACEFOR(val,vallen,"%s","null"); } break; case NMDIntarray : { struct NMD_intarray_struct *arraystruct = (struct NMD_intarray_struct *)(cmp->ii); int n = arraystruct->length,i; if (arrays || n<=4) { for (i=0; i<n; i++) { if (i<n-1) { CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[i]); } else { CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[i]); } } } else { CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[0]); CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[1]); CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[n-2]); CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[n-1]); } } ; break; case NMDRealarray : { struct NMD_realarray_struct *arraystruct = (struct NMD_realarray_struct *)(cmp->rr); int n = arraystruct->length,i; if (arrays || n<=4) { for (i=0; i<n; i++) { if (i<n-1) { CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[i]); } else { CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[i]); } } } else { CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[0]); CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[1]); CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[n-2]); CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[n-1]); } } ; break; default : CHKSPACEFOR(val,vallen,"%s","==="); break; } delimiter: if (itemdelim2) CHKSPACEFOR(val,vallen,"%c",itemdelim2); CHKSPACEFOR(val,vallen,"%c",delim); } } } write += 1; if (write<=1) goto writeloop; NMD_FREE(scratch); CHKMEMQ; /* *rkey = key; *rval = val; */ if (key) { int l = strlen(key); if (l>keylen) NMD_ERR_REPORT("key string overrun"); *rkey = key; } if (val) { int l = strlen(val); if (l>vallen) NMD_ERR_REPORTii("val string overrun; alloc/actual",vallen,l); *rval = val; } return 0; }
NMDErrorCode NMDSetArrayValue | ( | NMD_metadata | obj, |
const char * | cat, | ||
const char * | cmp, | ||
NMDDataType | t, | ||
void * | v, | ||
int | l | ||
) |
Set a metadata value, if it is an array type.
The arrays are not copied, so the user is responsible for freeing the array. Use NMDCopyArrayValue() to have the array copied; NMD will then free the array when the metadata object is freed.
This call can be used to create categories and components; there is no checking of slight misspellings.
See also Value handling.
Definition at line 494 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryGetOrCreateComponent(), NMDComponentSetArrayValue(), and NMDObjectGetOrCreateCategory().
Referenced by main().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); ierr = NMDComponentSetArrayValue(cpt,t,v,l); NMD_ERR_RETURN(ierr); CHKMEMQ return 0; }
NMDErrorCode NMDSetValue | ( | NMD_metadata | obj, |
const char * | cat, | ||
const char * | cmp, | ||
NMDDataType | t, | ||
void * | v | ||
) |
Set a metadata value, indexed by category and component name.
The value has to be passed by reference
String values are copied. (Reason: literal strings are treated differently from allocated, and Petsc has its own way of doing strings.)
This call can be used to create categories and components; there is no checking of slight misspellings.
See also Value handling.
Definition at line 451 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryGetOrCreateComponent(), NMDComponentSetValue(), and NMDObjectGetOrCreateCategory().
Referenced by main(), and NMDCopyArrayValue().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); ierr = NMDComponentSetValue(cpt,t,v); NMD_ERR_RETURN(ierr); CHKMEMQ return 0; }
NMDErrorCode NMDStringAppend | ( | char | s1, |
NMD_string * | str1, | ||
char | s2, | ||
NMD_string | str2, | ||
char | s3 | ||
) |
A version of NMDStringConcat() that appends to string 1, rather than creating a new string.
Definition at line 121 of file nmdutil.c.
References CHECKHASNMDCOOKIE, NMDStringConcat(), and NMDStringDestroy().
Referenced by NMDObjectDumpToMySQL().
{ NMD_string nnew; NMDErrorCode ierr; CHECKHASNMDCOOKIE(*str1); CHECKHASNMDCOOKIE(str2); ierr = NMDStringConcat(s1,*str1,s2,str2,s3,&nnew); NMD_ERR_RETURN(ierr); ierr = NMDStringDestroy(*str1); NMD_ERR_RETURN(ierr); *str1 = nnew; return 0; }
NMDErrorCode NMDStringConcat | ( | char | s1, |
NMD_string | str1, | ||
char | s2, | ||
NMD_string | str2, | ||
char | s3, | ||
NMD_string * | r_str | ||
) |
Concatenate string objects, with delimiter characters before, after, in between. All delimiters, and the second string, can be null.
Definition at line 74 of file nmdutil.c.
References CHECKHASNMDCOOKIE, NMD_string_::n, NMDStringCreateOfSize(), and NMD_string_::t.
Referenced by NMDObjectDumpToMySQL(), and NMDStringAppend().
{ NMD_string str; NMDErrorCode ierr; int l; CHECKHASNMDCOOKIE(str1); l = str1->n + ( str2 ? str2->n : 0 ) + (s1!=0) + (s2!=0) + (s3!=0); ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr); l = 0; if (s1) { if (l+1>str->n) NMD_ERR_REPORT("string overflow"); memcpy(str->t+l,&s1,1); } l = strlen(str->t); if (l+str1->n>str->n) NMD_ERR_REPORT("string overflow"); memcpy(str->t+l,str1->t,str1->n); if (s2) { CHECKHASNMDCOOKIE(str2); l = strlen(str->t); if (l+1>str->n) NMD_ERR_REPORT("string overflow"); memcpy(str->t+l,&s2,1); } if (str2) { l = strlen(str->t); if (l+str2->n>str->n) NMD_ERR_REPORT("string overflow"); memcpy(str->t+l,str2->t,str2->n); } if (s3) { l = strlen(str->t); if (l+1>str->n) NMD_ERR_REPORT("string overflow"); memcpy(str->t+l,&s3,1); } *r_str = str; return 0; }
NMDErrorCode NMDStringCreate | ( | const char * | txt, |
NMD_string * | r_str | ||
) |
Create a string object around a C string; the C string is copied, so it can be freed by the calling environment.
Definition at line 36 of file nmdutil.c.
References NMDStringCreateOfSize(), and NMD_string_::t.
Referenced by NMDObjectDumpToMySQL().
{ NMD_string str; NMDErrorCode ierr; int l; l = strlen(txt); ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr); if (l) memcpy(str->t,txt,l); *r_str = str; return 0; }
NMDErrorCode NMDStringDestroy | ( | NMD_string | str | ) |
Destroy a string object, and free the stored string.
Definition at line 49 of file nmdutil.c.
References CHECKHASNMDCOOKIE, NMD_FREE, and NMD_string_::t.
Referenced by NMDObjectDumpToMySQL(), and NMDStringAppend().
{ CHECKHASNMDCOOKIE(str); NMD_FREE(str->t); NMD_FREE(str); return 0; }
NMDErrorCode NMDStringGetString | ( | NMD_string | str, |
const char ** | t | ||
) |
Return a pointer to the string in a string object
Definition at line 60 of file nmdutil.c.
References CHECKHASNMDCOOKIE, and NMD_string_::t.
Referenced by NMDObjectDumpToMySQL().
{ CHECKHASNMDCOOKIE(str); *t = str->t; return 0; }
NMDErrorCode NMDUnsetValue | ( | NMD_metadata | , |
const char * | , | ||
const char * | |||
) |
Definition at line 464 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), NMDComponentUnsetValue(), and NMDObjectTryGetCategory().
{ NMD_metadata_category ctg; NMD_metadata_item cpt; NMDTruth flg; NMDErrorCode ierr; CHECKHASNMDCOOKIE(obj); ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr); if (!flg) return 0; ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr); if (!flg) return 0; ierr = NMDComponentUnsetValue(cpt); NMD_ERR_RETURN(ierr); CHKMEMQ return 0; }
NMDErrorCode NMDViewObject | ( | NMD_metadata | obj | ) |
Print out an NMD object.
Currently only int, real, string fields are displayed, others are displayed as "***"
.
Definition at line 245 of file nmd.c.
References NMD_metadata_::cats, NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::i, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDInt, NMDReal, NMDString, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.
{ int icat,icmp; CHECKHASNMDCOOKIE(obj); printf("========\n"); for (icat=0; icat<obj->ncat; icat++) { NMD_metadata_category cat = obj->cats[icat]; CHECKHASNMDCOOKIE(cat); printf("Category: <%s>\n",cat->name); for (icmp=0; icmp<cat->ncmp; icmp++) { NMD_metadata_item cmp = cat->cmps[icmp]; CHECKHASNMDCOOKIE(cmp); printf(" <%s> : ",cmp->name); if (!cmp->set) { printf("(null)\n"); } else { switch (cmp->t) { case NMDInt : printf("<%d>\n",cmp->i); break; case NMDReal : printf("<%e>\n",cmp->r); break; case NMDString : printf("<<%s>>\n",cmp->cc); break; default : printf("****\n"); break; } } } } printf("========\n\n"); CHKMEMQ return 0; }