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(), NMDObjectEnsureCategoryComponent(), NMDObjectGetCategory(), NMDObjectGetOrCreateCategory(), NMDObjectHasCategoryComponent(), NMDObjectTryGetCategory(), NMDRemoveCategory(), NMDReportObject(), NMDSetArrayValue(), NMDSetValue(), NMDStringConcat(), NMDStringDestroy(), NMDStringGetString(), NMDUnsetValue(), and NMDViewObject().
#define NMD_FREE | ( | a | ) | {free(a);} |
Definition at line 142 of file nmd.h.
Referenced by main(), NMDComponentDestroy(), NMDComponentUnsetValue(), NMDDestroyObject(), NMDRemoveCategory(), NMDReportObject(), and NMDStringDestroy().
#define NMD_MALLOC | ( | a, | |||
b, | |||||
c, | |||||
d | ) |
Value:
{ a = (c*)malloc((b)*sizeof(c)); \ if (!a) NMD_ERR_REPORTs("Could not allocate",d); \ memset(a,0,(b)*sizeof(c)); }
Definition at line 138 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 143 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 |
Definition at line 28 of file nmd.h.
00028 { 00029 NMDInvalid, NMDInt, NMDReal, NMDString, NMDIntarray, NMDRealarray 00030 } 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().
00042 { 00043 NMD_metadata_item cpt; int idx; NMDErrorCode ierr; 00044 /* 00045 * if we are about to overflow, 00046 * reallocate the components in this category 00047 */ 00048 if (cat->ncmp >= cat->alloc) { 00049 NMD_metadata_item* newcmps; int newalloc; 00050 newalloc = 2*cat->alloc; 00051 ierr = PetscMalloc 00052 (newalloc*sizeof(struct NMD_metadata_item_),&newcmps); CHKERRQ(ierr); 00053 for (idx=0; idx<cat->ncmp; idx++) 00054 newcmps[idx] = cat->cmps[idx]; 00055 ierr = PetscFree(cat->cmps); CHKERRQ(ierr); 00056 cat->cmps = newcmps; cat->alloc = newalloc; 00057 } 00058 /* 00059 * with space guaranteed, create the component 00060 */ 00061 idx = cat->ncmp++; 00062 ierr = NMDAllocateComponent(&cpt); NMD_ERR_RETURN(ierr); 00063 NMD_STRDUP(cmp,cpt->name); cpt->t = type; cpt->set = NMDFalse; 00064 cat->cmps[idx] = cpt; 00065 if (rcpt) *rcpt = cpt; 00066 CHKMEMQ 00067 return 0; 00068 }
NMDErrorCode NMDCategoryCreateComponent | ( | NMD_metadata | , | |
char * | , | |||
char * | ||||
) |
NMDErrorCode NMDCategoryGetComponent | ( | NMD_metadata_category | cat, | |
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().
00235 { 00236 NMDTruth flg; NMDErrorCode ierr; 00237 CHECKHASNMDCOOKIE(cat); 00238 ierr = NMDCategoryTryGetComponent 00239 (cat,cmp,cpt,&flg); NMD_ERR_RETURN(ierr); 00240 if (!flg) NMD_ERR_REPORTss("Could not find component in category",cmp,cat->name); 00241 CHKMEMQ 00242 return 0; 00243 }
NMDErrorCode NMDCategoryGetComponents | ( | NMD_metadata | obj, | |
char * | cat, | |||
int * | ncmp, | |||
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().
00206 { 00207 NMD_metadata_category catobj; int icmp; 00208 char **names; NMDDataType *types; NMDErrorCode ierr; 00209 CHECKHASNMDCOOKIE(obj); 00210 ierr = NMDObjectGetCategory(obj,cat,&catobj); CHKERRQ(ierr); 00211 if (ncmp) *ncmp = catobj->ncmp; 00212 if (cmps) { 00213 NMD_MALLOC(names,catobj->ncmp,char*,"name array"); 00214 for (icmp=0; icmp<catobj->ncmp; icmp++) 00215 names[icmp] = catobj->cmps[icmp]->name; 00216 *cmps = names; 00217 } 00218 if (typs) { 00219 NMD_MALLOC(types,catobj->ncmp,NMDDataType,"type array"); 00220 for (icmp=0; icmp<catobj->ncmp; icmp++) 00221 types[icmp] = catobj->cmps[icmp]->t; 00222 *typs = types; 00223 } 00224 CHKMEMQ 00225 return 0; 00226 }
NMDErrorCode NMDCategoryGetOrCreateComponent | ( | NMD_metadata_category | cat, | |
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().
00109 { 00110 NMD_metadata_item cnew; NMDTruth flg; NMDErrorCode ierr; 00111 CHECKHASNMDCOOKIE(cat); 00112 ierr = NMDCategoryTryGetComponent(cat,cmp,&cnew,&flg); NMD_ERR_RETURN(ierr); 00113 if (flg) { 00114 if (type!=cnew->t) 00115 NMD_ERR_REPORTii 00116 ("Type incompatibility: old/new",(int)(cnew->t),(int)type); 00117 if (cpt) *cpt = cnew; 00118 } else { 00119 ierr = NMDCategoryAllocateNewComponent 00120 (cat,cmp,type,cpt); NMD_ERR_RETURN(ierr); 00121 } 00122 CHKMEMQ 00123 return 0; 00124 }
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().
00179 { 00180 int icmp; 00181 CHECKHASNMDCOOKIE(cat); 00182 *f = NMDFalse; 00183 for (icmp=0; icmp<cat->ncmp; icmp++) { 00184 NMD_metadata_item cpt = cat->cmps[icmp]; 00185 CHECKHASNMDCOOKIE(cpt); 00186 if (strcmp(cmp,cpt->name)==0) { 00187 *f = NMDTrue; 00188 if (rcpt) *rcpt = cpt; 00189 break; 00190 } 00191 } 00192 CHKMEMQ 00193 return 0; 00194 }
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().
00211 { 00212 int icat; NMDErrorCode ierr; 00213 00214 CHECKHASNMDCOOKIE(old); 00215 CHECKHASNMDCOOKIE(nnew); 00216 for (icat=0; icat<old->ncat; icat++) { 00217 /* loop over input categories by index; output categories 00218 are retrieved by label, or newly created */ 00219 NMD_metadata_category oldcat = old->cats[icat],newcat; int icmp; 00220 ierr = NMDObjectGetOrCreateCategory 00221 (nnew,oldcat->name,&newcat); NMD_ERR_RETURN(ierr); 00222 CHECKHASNMDCOOKIE(oldcat); 00223 for (icmp=0; icmp<oldcat->ncmp; icmp++) { 00224 NMD_metadata_item oldcmp = oldcat->cmps[icmp],newcmp; 00225 ierr = NMDCategoryGetOrCreateComponent 00226 (newcat,oldcmp->name,oldcmp->t,&newcmp); NMD_ERR_RETURN(ierr); 00227 ierr = NMDCopyItemValues(oldcmp,newcmp); NMD_ERR_RETURN(ierr); 00228 } 00229 } 00230 CHKMEMQ 00231 return 0; 00232 }
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().
00182 { 00183 NMD_metadata nnew; 00184 int icat,icmp; NMDErrorCode ierr; 00185 00186 CHECKHASNMDCOOKIE(old); 00187 ierr = NMDCreateObject(&nnew); NMD_ERR_RETURN(ierr); 00188 CHECKHASNMDCOOKIE(nnew); 00189 for (icat=0; icat<old->ncat; icat++) { 00190 NMD_metadata_category oldcat = old->cats[icat]; 00191 CHECKHASNMDCOOKIE(oldcat); 00192 for (icmp=0; icmp<oldcat->ncmp; icmp++) { 00193 NMD_metadata_item oldcmp = oldcat->cmps[icmp]; 00194 CHECKHASNMDCOOKIE(oldcmp); 00195 ierr = NMDObjectEnsureCategoryComponent 00196 (nnew,oldcat->name,oldcmp->name,oldcmp->t,NULL); NMD_ERR_RETURN(ierr); 00197 } 00198 } 00199 CHKMEMQ 00200 *ret = nnew; 00201 return 0; 00202 }
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().
00073 { 00074 switch (cmp->t) { 00075 case NMDIntarray : 00076 if (cmp->ii) { 00077 struct NMD_intarray_struct *arraystruct = 00078 (struct NMD_intarray_struct *)(cmp->ii); 00079 if (arraystruct->length>0 && arraystruct->unique==1) 00080 NMD_FREE(arraystruct->data); 00081 NMD_FREE(cmp->ii); 00082 } ; 00083 break; 00084 case NMDRealarray : 00085 if (cmp->rr) { 00086 struct NMD_realarray_struct *arraystruct = 00087 (struct NMD_realarray_struct *)(cmp->rr); 00088 if (arraystruct->length>0 && arraystruct->unique==1) 00089 NMD_FREE(arraystruct->data); 00090 NMD_FREE(cmp->rr); 00091 } ; 00092 break; 00093 case NMDString : NMD_FREE(cmp->cc); 00094 break; 00095 default : /* other components need no destructor */ 00096 break; 00097 } 00098 NMD_FREE(cmp->name); 00099 NMD_FREE(cmp); 00100 return 0; 00101 }
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().
00324 { 00325 NMDErrorCode ierr; 00326 CHECKHASNMDCOOKIE(cpt); 00327 switch (cpt->t) { 00328 case NMDInt : 00329 case NMDReal : 00330 case NMDString : 00331 ierr = NMDComponentSetValue(cpt,cpt->t,v); NMD_ERR_RETURN(ierr); 00332 break; 00333 case NMDIntarray : { 00334 struct NMD_intarray_struct* iistruct; 00335 NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct"); 00336 iistruct->unique = 0; iistruct->length = l; 00337 iistruct->data = *(int**)v; 00338 cpt->ii = iistruct; 00339 break;} 00340 case NMDRealarray : { 00341 struct NMD_realarray_struct* rrstruct; 00342 NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct"); 00343 rrstruct->unique = 0; rrstruct->length = l; 00344 rrstruct->data = *(NMDRealtype**)v; 00345 cpt->rr = rrstruct; 00346 break;} 00347 default : 00348 NMD_ERR_REPORTi("Unknown type",(int)t) 00349 } 00350 cpt->set = NMDTrue; 00351 return 0; 00352 }
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().
00279 { 00280 CHECKHASNMDCOOKIE(cpt); 00281 if (t!=cpt->t) NMD_ERR_REPORT("Type conflict"); 00282 switch (cpt->t) { 00283 case NMDInt : cpt->i = *(int*)v; break; 00284 case NMDReal : cpt->r = *(double*)v; break; 00285 case NMDString : NMD_STRDUP((char*)v,cpt->cc); break; 00286 case NMDIntarray : 00287 case NMDRealarray : 00288 NMD_ERR_REPORT("Please use NMDSetArrayValue"); break; 00289 default : NMD_ERR_REPORTi("Unknown type",(int)t); break; 00290 } 00291 cpt->set = NMDTrue; 00292 return 0; 00293 }
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().
00298 { 00299 CHECKHASNMDCOOKIE(cpt); 00300 switch (cpt->t) { 00301 case NMDInt : 00302 case NMDReal : break; 00303 case NMDString : NMD_FREE(cpt->cc); break; 00304 case NMDIntarray : { 00305 struct NMD_intarray_struct* iistruct = cpt->ii; 00306 NMD_FREE(iistruct->data); 00307 NMD_FREE(iistruct); 00308 break;} 00309 case NMDRealarray : { 00310 struct NMD_realarray_struct* rrstruct = cpt->rr; 00311 NMD_FREE(rrstruct->data); 00312 NMD_FREE(rrstruct); 00313 break;} 00314 default : NMD_ERR_REPORTi("Unknown type",cpt->t); break; 00315 } 00316 cpt->set = NMDFalse; 00317 return 0; 00318 }
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().
00519 { 00520 NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; 00521 00522 CHECKHASNMDCOOKIE(obj); 00523 ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); 00524 ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); 00525 00526 CHECKHASNMDCOOKIE(cpt); 00527 cpt->set = NMDTrue; 00528 switch (cpt->t) { 00529 case NMDInt : 00530 case NMDReal : 00531 case NMDString : 00532 ierr = NMDSetValue(obj,cat,cmp,t,v); NMD_ERR_RETURN(ierr); 00533 break; 00534 case NMDIntarray : { 00535 struct NMD_intarray_struct* iistruct; int *ii,i; 00536 NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct"); 00537 iistruct->unique = 1; iistruct->length = l; 00538 NMD_MALLOC(ii,l,sizeof(int),"copied int array"); 00539 for (i=0; i<l; i++) ii[i] = (*(int**)v)[i]; 00540 iistruct->data = ii; 00541 cpt->ii = iistruct; 00542 break;} 00543 case NMDRealarray : { 00544 struct NMD_realarray_struct* rrstruct; NMDRealtype *rr; int i; 00545 NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct"); 00546 rrstruct->unique = 1; rrstruct->length = l; 00547 NMD_MALLOC(rr,l,NMDRealtype,"copied real array"); 00548 for (i=0; i<l; i++) rr[i] = (*(NMDRealtype**)v)[i]; 00549 rrstruct->data = rr; 00550 cpt->rr = rrstruct; 00551 break;} 00552 default : NMD_ERR_REPORTi("Unknown type",(int)t); break; 00553 } 00554 CHKMEMQ 00555 00556 return 0; 00557 }
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.
00181 { 00182 int icmp; NMDErrorCode ierr; 00183 00184 CHECKHASNMDCOOKIE(incat); 00185 CHECKHASNMDCOOKIE(outcat); 00186 00187 for (icmp=0; icmp<incat->ncmp; icmp++) { 00188 NMD_metadata_item src = incat->cmps[icmp],tar; 00189 ierr = NMDCategoryGetOrCreateComponent 00190 (outcat,src->name,src->t,&tar); NMD_ERR_RETURN(ierr); 00191 ierr = NMDCopyItemValues(src,tar); NMD_ERR_RETURN(ierr); 00192 } 00193 CHKMEMQ 00194 00195 return 0; 00196 }
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().
00360 { 00361 tar->set = src->set; if (!src->set) goto done; 00362 switch (src->t) { 00363 case NMDInt : tar->i = src->i; break; 00364 case NMDReal : tar->r = src->r ; break; 00365 case NMDString : NMD_STRDUP(src->cc,tar->cc); break; 00366 case NMDIntarray : 00367 { 00368 struct NMD_intarray_struct *tarstruct,*srcstruct = src->ii; 00369 int length=srcstruct->length; 00370 NMD_MALLOC(tarstruct,1,struct NMD_intarray_struct,"copied int array"); 00371 tarstruct->length = length; tarstruct->unique = srcstruct->unique; 00372 if (srcstruct->unique) { 00373 int *a1=srcstruct->data,*a2; int i; 00374 NMD_MALLOC(a2,length,int,"int array data"); 00375 for (i=0; i<length; i++) a2[i] = a1[i]; 00376 tarstruct->data = a2; 00377 } else 00378 tarstruct->data = srcstruct->data; 00379 tar->ii = tarstruct; 00380 } ; 00381 break; 00382 case NMDRealarray : 00383 { 00384 struct NMD_realarray_struct *tarstruct,*srcstruct = src->rr; 00385 int length=srcstruct->length; 00386 NMD_MALLOC(tarstruct,1,struct NMD_realarray_struct,"copied real array"); 00387 tarstruct->length = length; tarstruct->unique = srcstruct->unique; 00388 if (srcstruct->unique) { 00389 NMDRealtype *a1=srcstruct->data,*a2; int i; 00390 NMD_MALLOC(a2,length,NMDRealtype,"real array data"); 00391 for (i=0; i<length; i++) a2[i] = a1[i]; 00392 tarstruct->data = a2; 00393 } else 00394 tarstruct->data = srcstruct->data; 00395 tar->rr = tarstruct; 00396 } ; 00397 break; 00398 default : NMD_ERR_REPORTi("Can not copy items of type",(int)(src->t)); 00399 break; 00400 } 00401 done: 00402 CHKMEMQ 00403 return 0; 00404 }
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().
00109 { 00110 NMD_metadata nnew; 00111 00112 /* allocate the metadata object */ 00113 NMD_MALLOC(nnew,1,struct NMD_metadata_,"object"); 00114 nnew->cookie = NMDCOOKIE; 00115 *obj = nnew; 00116 00117 /* give it a basic array of categories */ 00118 nnew->alloc = CATCHUNK; nnew->ncat = 0; 00119 NMD_MALLOC(nnew->cats,nnew->alloc,NMD_metadata_category,"categories"); 00120 00121 CHKMEMQ 00122 return 0; 00123 }
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().
00131 { 00132 int i,j; NMDErrorCode ierr; 00133 00134 CHECKHASNMDCOOKIE(obj); 00135 for (i=0; i<obj->ncat; i++) { 00136 NMD_metadata_category cat = obj->cats[i]; 00137 for (j=0; j<cat->ncmp; j++) { 00138 NMD_metadata_item cmp = cat->cmps[j]; 00139 ierr = NMDComponentDestroy(cmp); NMD_ERR_RETURN(ierr); 00140 } 00141 NMD_FREE(cat->cmps); 00142 NMD_FREE(cat->name); 00143 NMD_FREE(cat); 00144 CHKMEMQ 00145 } 00146 NMD_FREE(obj->cats); 00147 NMD_FREE(obj); 00148 00149 return 0; 00150 }
NMDErrorCode NMDDestroyObjectStructure | ( | NMD_metadata | ) |
NMDErrorCode NMDGetArrayValue | ( | NMD_metadata | obj, | |
char * | cat, | |||
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().
00634 { 00635 NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; 00636 00637 CHECKHASNMDCOOKIE(obj); 00638 ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); 00639 CHECKHASNMDCOOKIE(ctg); 00640 ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr); 00641 CHECKHASNMDCOOKIE(cpt); 00642 if (!cpt->set) { 00643 if (f) { 00644 *f = NMDFalse; return 0; 00645 } else NMD_ERR_REPORT 00646 ("Value not set, but no flag given to report this"); 00647 } 00648 if (t) *t = cpt->t; 00649 switch (cpt->t) { 00650 case NMDInt : 00651 case NMDReal : 00652 case NMDString : 00653 ierr = NMDGetValue(obj,cat,cmp,NULL,v,f); NMD_ERR_RETURN(ierr); 00654 break; 00655 case NMDIntarray : 00656 if (v || len) { 00657 struct NMD_intarray_struct *as = cpt->ii; 00658 if (v) *(int**)v = as->data; 00659 if (len) *len = as->length; 00660 } 00661 if (f) *f = NMDTrue; break; 00662 case NMDRealarray : 00663 if (v || len) { 00664 struct NMD_realarray_struct *as = cpt->rr; 00665 if (v) *(NMDRealtype**)v = as->data; 00666 if (len) *len = as->length; 00667 } 00668 if (f) *f = NMDTrue; break; 00669 default : 00670 if (f) *f = NMDFalse; 00671 } 00672 CHKMEMQ 00673 return 0; 00674 }
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().
00138 { 00139 CHECKHASNMDCOOKIE(obj); 00140 if (ncat) *ncat = obj->ncat; 00141 if (obj->ncat && cats) { 00142 char **names; int icat; 00143 NMD_MALLOC(names,obj->ncat,char*,"name array"); 00144 for (icat=0; icat<obj->ncat; icat++) 00145 names[icat] = obj->cats[icat]->name; 00146 *cats = names; 00147 } 00148 CHKMEMQ 00149 return 0; 00150 }
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.
00256 { 00257 NMD_metadata_category cat; 00258 CHECKHASNMDCOOKIE(obj); 00259 cat = obj->cats[icat]; 00260 if (ncmp) *ncmp = cat->ncmp; 00261 if (cat->ncmp && (cmps || typs) ) { 00262 NMDDataType *types; char **names; int icmp; 00263 if (cmps) 00264 NMD_MALLOC(names,cat->ncmp,char*,"name array"); 00265 if (typs) 00266 NMD_MALLOC(types,cat->ncmp,NMDDataType,"name array"); 00267 for (icmp=0; icmp<cat->ncmp; icmp++) { 00268 if (cmps) names[icmp] = cat->cmps[icmp]->name; 00269 if (typs) types[icmp] = cat->cmps[icmp]->t; 00270 } 00271 if (cmps) *cmps = names; if (typs) *typs = types; 00272 } 00273 return 0; 00274 }
NMDErrorCode NMDGetDataType | ( | NMD_metadata | , | |
char * | , | |||
char * | , | |||
NMDDataType * | t | |||
) |
Definition at line 720 of file nmd.c.
References CHECKHASNMDCOOKIE, NMDCategoryGetComponent(), NMDObjectGetCategory(), and NMD_metadata_item_::t.
00721 { 00722 NMD_metadata_category ctg; NMD_metadata_item cpt; 00723 NMDErrorCode ierr; 00724 00725 CHECKHASNMDCOOKIE(obj); 00726 ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); 00727 ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr); 00728 CHECKHASNMDCOOKIE(cmp); 00729 *t = cpt->t; 00730 00731 return 0; 00732 }
PetscErrorCode NMDGetTypeMySQLName | ( | NMDDataType | , | |
char ** | ||||
) |
Definition at line 745 of file nmd.c.
References mysqltypenames, and nnmdtypenames.
Referenced by main().
00746 { 00747 int itype = (int)(type); 00748 if (itype<0 || itype>=nnmdtypenames) 00749 NMD_ERR_REPORTi("Invalid type",itype); 00750 *name = (char*)mysqltypenames[itype]; 00751 return 0; 00752 }
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().
00572 { 00573 NMD_metadata_category ctg; NMD_metadata_item cpt; 00574 NMDTruth ff; NMDErrorCode ierr; 00575 00576 CHECKHASNMDCOOKIE(obj); 00577 ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&ff); NMD_ERR_RETURN(ierr); 00578 if (!ff) { 00579 if (f) { 00580 *f = NMDFalse; return 0; 00581 } else NMD_ERR_REPORT 00582 ("Could not find category, but no flag given to report this"); 00583 } 00584 CHECKHASNMDCOOKIE(ctg); 00585 ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&ff); NMD_ERR_RETURN(ierr); 00586 if (!ff) { 00587 if (f) { 00588 *f = NMDFalse; return 0; 00589 } else NMD_ERR_REPORT 00590 ("Could not find component, but no flag given to report this"); 00591 } 00592 CHECKHASNMDCOOKIE(cpt); 00593 if (!cpt->set) { 00594 if (f) { 00595 *f = NMDFalse; return 0; 00596 } else NMD_ERR_REPORT 00597 ("Value not set, but no flag given to report this"); 00598 } 00599 if (t) *t = cpt->t; 00600 switch (cpt->t) { 00601 case NMDInt : 00602 if (v) *(int*)v = cpt->i; 00603 if (f) *f = NMDTrue; break; 00604 case NMDReal : 00605 if (v) *(double*)v = cpt->r; 00606 if (f) *f = NMDTrue; break; 00607 case NMDString : 00608 if (v) *(char**)v = cpt->cc; 00609 if (f) *f = NMDTrue; break; 00610 case NMDIntarray : 00611 case NMDRealarray : 00612 NMD_ERR_REPORT("Please use NMDGetArrayValue"); break; 00613 default : 00614 if (f) *f = NMDFalse; 00615 } 00616 CHKMEMQ 00617 return 0; 00618 }
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().
00738 { 00739 *flg = ( (type==NMDIntarray) || (type==NMDRealarray) ? NMDTrue : NMDFalse ) ; 00740 return 0; 00741 }
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().
00085 { 00086 NMD_metadata_category ctg; int idx; NMDErrorCode ierr; 00087 /* 00088 * if we are about to overflow, reallocate 00089 */ 00090 if (obj->ncat >= obj->alloc) { 00091 NMD_metadata_category* newcats; int newalloc; 00092 newalloc = 2*obj->alloc; 00093 ierr = PetscMalloc 00094 (newalloc*sizeof(struct NMD_metadata_category_),&newcats); CHKERRQ(ierr); 00095 for (idx=0; idx<obj->ncat; idx++) 00096 newcats[idx] = obj->cats[idx]; 00097 ierr = PetscFree(obj->cats); CHKERRQ(ierr); 00098 obj->cats = newcats; obj->alloc = newalloc; 00099 } 00100 /* 00101 * with space guaranteed, create the category 00102 */ 00103 idx = obj->ncat++; 00104 ierr = NMDAllocateCategory(&ctg); NMD_ERR_RETURN(ierr); 00105 NMD_STRDUP(cat,ctg->name); 00106 obj->cats[idx] = ctg; 00107 if (rctg) *rctg = ctg; 00108 CHKMEMQ 00109 return 0; 00110 }
NMDErrorCode NMDObjectEnsureCategoryComponent | ( | NMD_metadata | , | |
char * | , | |||
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().
00135 { 00136 NMD_metadata_category ctg; NMD_metadata_item cpt; 00137 NMDTruth flg; NMDErrorCode ierr; 00138 CHECKHASNMDCOOKIE(obj); 00139 ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr); 00140 if (!flg) { 00141 ierr = NMDObjectAllocateNewCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr); 00142 } 00143 ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr); 00144 if (flg) { 00145 if (nnew) *nnew = NMDFalse; 00146 if (type!=cpt->t) 00147 NMD_ERR_REPORTii 00148 ("Type incompatibility: old/new",(int)(cpt->t),(int)type); 00149 } else { 00150 if (nnew) *nnew = NMDTrue; 00151 ierr = NMDCategoryAllocateNewComponent 00152 (ctg,cmp,type,NULL); NMD_ERR_RETURN(ierr); 00153 } 00154 CHKMEMQ 00155 return 0; 00156 }
NMDErrorCode NMDObjectGetCategory | ( | NMD_metadata | obj, | |
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().
00050 { 00051 NMDTruth flg; NMDErrorCode ierr; 00052 CHECKHASNMDCOOKIE(obj); 00053 ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr); 00054 if (!flg) NMD_ERR_REPORTs("Category not found",cat); 00055 return 0; 00056 }
NMDErrorCode NMDObjectGetOrCreateCategory | ( | NMD_metadata | obj, | |
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().
00119 { 00120 NMDTruth flg; NMDErrorCode ierr; 00121 CHECKHASNMDCOOKIE(obj); 00122 ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr); 00123 if (!flg) { 00124 ierr = NMDObjectAllocateNewCategory(obj,cat,ctg); NMD_ERR_RETURN(ierr); 00125 } 00126 CHKMEMQ 00127 return 0; 00128 }
NMDErrorCode NMDObjectHasCategoryComponent | ( | NMD_metadata | , | |
char * | , | |||
char * | , | |||
NMDTruth * | ||||
) |
Definition at line 161 of file nmdcmp.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), and NMDObjectTryGetCategory().
Referenced by main().
00162 { 00163 NMD_metadata_category ctg; NMDErrorCode ierr; 00164 CHECKHASNMDCOOKIE(obj); 00165 ierr = NMDObjectTryGetCategory(obj,cat,&ctg,f); NMD_ERR_RETURN(ierr); 00166 if (*f) { 00167 ierr = NMDCategoryTryGetComponent(ctg,cmp,NULL,f); NMD_ERR_RETURN(ierr); 00168 } 00169 CHKMEMQ 00170 return 0; 00171 }
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().
00030 { 00031 int icat; 00032 CHECKHASNMDCOOKIE(obj); 00033 *f = NMDFalse; 00034 for (icat=0; icat<obj->ncat; icat++) { 00035 NMD_metadata_category ctg = obj->cats[icat]; 00036 CHECKHASNMDCOOKIE(ctg); 00037 if (strcmp(cat,ctg->name)==0) { 00038 if (rctg) *rctg = ctg; *f = NMDTrue; break; 00039 } 00040 } 00041 return 0; 00042 }
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().
00161 { 00162 NMD_metadata_category ctg; NMDErrorCode ierr; 00163 00164 CHECKHASNMDCOOKIE(obj); 00165 ierr = NMDObjectGetCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); 00166 NMD_FREE(ctg->name); 00167 NMD_STRDUP("invalid",ctg->name); 00168 CHKMEMQ 00169 00170 return 0; 00171 }
NMDErrorCode NMDReportObject | ( | NMD_metadata | obj, | |
NMDTruth | arrays, | |||
char ** | rkey, | |||
char ** | rval, | |||
char | delim, | |||
char | itemdelim1, | |||
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().
00299 { 00300 int icat,icmp,write,keylen,vallen; char *key=NULL,*val=NULL, *scratch; 00301 CHECKHASNMDCOOKIE(obj); 00302 00303 /* 00304 * allocate and fill in the key and value strings 00305 */ 00306 #define CHKLEN 500 00307 NMD_MALLOC(scratch,CHKLEN,char,"scratch pad"); 00308 #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");}} 00309 write = 0; 00310 writeloop: 00311 if (write==0) { 00312 keylen=vallen=0; 00313 } else { 00314 if (rkey) NMD_MALLOC(key,keylen,char,"names array"); 00315 if (rval) NMD_MALLOC(val,vallen,char,"values array"); 00316 } 00317 for (icat=0; icat<obj->ncat; icat++) { 00318 NMD_metadata_category cat = obj->cats[icat]; 00319 CHECKHASNMDCOOKIE(cat); 00320 for (icmp=0; icmp<cat->ncmp; icmp++) { 00321 NMD_metadata_item cmp = cat->cmps[icmp]; 00322 CHECKHASNMDCOOKIE(cmp); 00323 if (rkey) { 00324 if (itemdelim1) CHKSPACEFOR(key,keylen,"%c",itemdelim1); 00325 CHKSPACEFOR(key,keylen,"%s:",cat->name); 00326 CHKSPACEFOR(key,keylen,"%s",cmp->name); 00327 if (itemdelim2) CHKSPACEFOR(key,keylen,"%c",itemdelim2); 00328 CHKSPACEFOR(key,keylen,"%c",delim); 00329 } 00330 if (rval) { 00331 if (itemdelim1) CHKSPACEFOR(val,vallen,"%c",itemdelim1); 00332 if (!cmp->set) goto delimiter; 00333 switch (cmp->t) { 00334 case NMDInt : { 00335 CHKSPACEFOR(val,vallen,"%8d",cmp->i); break;} 00336 case NMDReal : { 00337 CHKSPACEFOR(val,vallen,"%15.8e",cmp->r); break;} 00338 case NMDString : 00339 if (!cmp->cc) NMD_ERR_REPORT("Null string"); 00340 if (strlen(cmp->cc)>0) { 00341 if (strlen(cmp->cc)<=CHKLEN) { 00342 CHKSPACEFOR(val,vallen,"%s",cmp->cc); 00343 } else {CHKSPACEFOR(val,vallen,"%s","stringtoolong");} 00344 } else { 00345 CHKSPACEFOR(val,vallen,"%s","null"); 00346 } 00347 break; 00348 case NMDIntarray : { 00349 struct NMD_intarray_struct *arraystruct = 00350 (struct NMD_intarray_struct *)(cmp->ii); 00351 int n = arraystruct->length,i; 00352 if (arrays || n<=4) { 00353 for (i=0; i<n; i++) { 00354 if (i<n-1) { 00355 CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[i]); 00356 } else { 00357 CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[i]); 00358 } 00359 } 00360 } else { 00361 CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[0]); 00362 CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[1]); 00363 CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[n-2]); 00364 CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[n-1]); 00365 } 00366 } ; break; 00367 case NMDRealarray : { 00368 struct NMD_realarray_struct *arraystruct = 00369 (struct NMD_realarray_struct *)(cmp->rr); 00370 int n = arraystruct->length,i; 00371 if (arrays || n<=4) { 00372 for (i=0; i<n; i++) { 00373 if (i<n-1) { 00374 CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[i]); 00375 } else { 00376 CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[i]); 00377 } 00378 } 00379 } else { 00380 CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[0]); 00381 CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[1]); 00382 CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[n-2]); 00383 CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[n-1]); 00384 } 00385 } ; break; 00386 default : 00387 CHKSPACEFOR(val,vallen,"%s","==="); break; 00388 } 00389 delimiter: 00390 if (itemdelim2) CHKSPACEFOR(val,vallen,"%c",itemdelim2); 00391 CHKSPACEFOR(val,vallen,"%c",delim); 00392 } 00393 } 00394 } 00395 write += 1; 00396 if (write<=1) goto writeloop; 00397 NMD_FREE(scratch); 00398 CHKMEMQ; 00399 /* *rkey = key; *rval = val; */ 00400 if (key) { 00401 int l = strlen(key); 00402 if (l>keylen) 00403 NMD_ERR_REPORT("key string overrun"); 00404 *rkey = key; 00405 } 00406 if (val) { 00407 int l = strlen(val); 00408 if (l>vallen) 00409 NMD_ERR_REPORTii("val string overrun; alloc/actual",vallen,l); 00410 *rval = val; 00411 } 00412 00413 return 0; 00414 }
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().
00495 { 00496 NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; 00497 00498 CHECKHASNMDCOOKIE(obj); 00499 ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); 00500 ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); 00501 ierr = NMDComponentSetArrayValue(cpt,t,v,l); NMD_ERR_RETURN(ierr); 00502 CHKMEMQ 00503 00504 return 0; 00505 }
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().
00452 { 00453 NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr; 00454 00455 CHECKHASNMDCOOKIE(obj); 00456 ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr); 00457 ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr); 00458 ierr = NMDComponentSetValue(cpt,t,v); NMD_ERR_RETURN(ierr); 00459 CHKMEMQ 00460 00461 return 0; 00462 }
NMDErrorCode NMDStringConcat | ( | char | , | |
NMD_string | , | |||
char | , | |||
NMD_string | , | |||
char | , | |||
NMD_string * | ||||
) |
Definition at line 57 of file nmdutil.c.
References CHECKHASNMDCOOKIE, NMD_string_::n, NMDStringCreateOfSize(), and NMD_string_::t.
00058 { 00059 NMD_string str; NMDErrorCode ierr; int l; 00060 CHECKHASNMDCOOKIE(str1); 00061 00062 l = str1->n + ( str2 ? str2->n : 0 ) + (s1!=0) + (s2!=0) + (s3!=0); 00063 ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr); 00064 00065 l = 0; 00066 if (s1) { 00067 if (l+1>str->n) NMD_ERR_REPORT("string overflow"); 00068 memcpy(str->t+l,&s1,1); 00069 } 00070 00071 l = strlen(str->t); 00072 if (l+str1->n>str->n) NMD_ERR_REPORT("string overflow"); 00073 memcpy(str->t+l,str1->t,str1->n); 00074 00075 if (s2) { 00076 CHECKHASNMDCOOKIE(str2); 00077 l = strlen(str->t); 00078 if (l+1>str->n) NMD_ERR_REPORT("string overflow"); 00079 memcpy(str->t+l,&s2,1); 00080 } 00081 00082 if (str2) { 00083 l = strlen(str->t); 00084 if (l+str2->n>str->n) NMD_ERR_REPORT("string overflow"); 00085 memcpy(str->t+l,str2->t,str2->n); 00086 } 00087 00088 if (s3) { 00089 l = strlen(str->t); 00090 if (l+1>str->n) NMD_ERR_REPORT("string overflow"); 00091 memcpy(str->t+l,&s3,1); 00092 } 00093 00094 *r_str = str; 00095 return 0; 00096 }
NMDErrorCode NMDStringCreate | ( | char * | , | |
NMD_string * | ||||
) |
Definition at line 25 of file nmdutil.c.
References NMDStringCreateOfSize(), and NMD_string_::t.
00026 { 00027 NMD_string str; NMDErrorCode ierr; int l; 00028 l = strlen(txt); 00029 ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr); 00030 memcpy(str->t,txt,l); 00031 *r_str = str; 00032 return 0; 00033 }
NMDErrorCode NMDStringDestroy | ( | NMD_string | ) |
Definition at line 37 of file nmdutil.c.
References CHECKHASNMDCOOKIE, NMD_FREE, and NMD_string_::t.
00038 { 00039 CHECKHASNMDCOOKIE(str); 00040 NMD_FREE(str->t); 00041 NMD_FREE(str); 00042 return 0; 00043 }
NMDErrorCode NMDStringGetString | ( | NMD_string | str, | |
char ** | t | |||
) |
Definition at line 47 of file nmdutil.c.
References CHECKHASNMDCOOKIE, and NMD_string_::t.
00048 { 00049 CHECKHASNMDCOOKIE(str); 00050 *t = str->t; 00051 return 0; 00052 }
NMDErrorCode NMDUnsetValue | ( | NMD_metadata | , | |
const char * | , | |||
const char * | ||||
) |
Definition at line 464 of file nmd.c.
References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), NMDComponentUnsetValue(), and NMDObjectTryGetCategory().
00465 { 00466 NMD_metadata_category ctg; NMD_metadata_item cpt; 00467 NMDTruth flg; NMDErrorCode ierr; 00468 00469 CHECKHASNMDCOOKIE(obj); 00470 ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr); 00471 if (!flg) return 0; 00472 ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr); 00473 if (!flg) return 0; 00474 ierr = NMDComponentUnsetValue(cpt); NMD_ERR_RETURN(ierr); 00475 CHKMEMQ 00476 00477 return 0; 00478 }
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.
00246 { 00247 int icat,icmp; 00248 CHECKHASNMDCOOKIE(obj); 00249 printf("========\n"); 00250 for (icat=0; icat<obj->ncat; icat++) { 00251 NMD_metadata_category cat = obj->cats[icat]; 00252 CHECKHASNMDCOOKIE(cat); 00253 printf("Category: <%s>\n",cat->name); 00254 for (icmp=0; icmp<cat->ncmp; icmp++) { 00255 NMD_metadata_item cmp = cat->cmps[icmp]; 00256 CHECKHASNMDCOOKIE(cmp); 00257 printf(" <%s> : ",cmp->name); 00258 if (!cmp->set) { 00259 printf("(null)\n"); 00260 } else { 00261 switch (cmp->t) { 00262 case NMDInt : printf("<%d>\n",cmp->i); break; 00263 case NMDReal : printf("<%e>\n",cmp->r); break; 00264 case NMDString : printf("<<%s>>\n",cmp->cc); break; 00265 default : printf("****\n"); break; 00266 } 00267 } 00268 } 00269 } 00270 printf("========\n\n"); 00271 CHKMEMQ 00272 return 0; 00273 }