nmd.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "nmd_impl.h"
#include "nmd.h"

Include dependency graph for nmd.c:

Go to the source code of this file.

Defines

#define CATCHUNK   10
#define CHKLEN   500
#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");}}

Functions

NMDErrorCode NMDCreateObject (NMD_metadata *obj)
NMDErrorCode NMDDestroyObject (NMD_metadata obj)
NMDErrorCode NMDCloneObjectStructure (NMD_metadata old, NMD_metadata *ret)
NMDErrorCode NMDCloneObject (NMD_metadata old, NMD_metadata nnew)
NMDErrorCode NMDViewObject (NMD_metadata obj)
NMDErrorCode NMDReportObject (NMD_metadata obj, NMDTruth arrays, char **rkey, char **rval, char delim, char itemdelim1, char itemdelim2)
NMDErrorCode NMDSetValue (NMD_metadata obj, const char *cat, const char *cmp, NMDDataType t, void *v)
NMDErrorCode NMDUnsetValue (NMD_metadata obj, const char *cat, const char *cmp)
NMDErrorCode NMDSetArrayValue (NMD_metadata obj, const char *cat, const char *cmp, NMDDataType t, void *v, int l)
NMDErrorCode NMDCopyArrayValue (NMD_metadata obj, const char *cat, const char *cmp, NMDDataType t, void *v, int l)
NMDErrorCode NMDGetValue (NMD_metadata obj, const char *cat, const char *cmp, NMDDataType *t, void *v, NMDTruth *f)
NMDErrorCode NMDGetArrayValue (NMD_metadata obj, char *cat, char *cmp, NMDDataType *t, void *v, int *len, NMDTruth *f)
NMDErrorCode NMDGetDataType (NMD_metadata obj, char *cat, char *cmp, NMDDataType *t)
NMDErrorCode NMDIsArrayType (NMDDataType type, NMDTruth *flg)
PetscErrorCode NMDGetTypeMySQLName (NMDDataType type, char **name)

Variables

const char * typenames []
const char * mysqltypenames []
static const int nnmdtypenames = 6


Define Documentation

#define CATCHUNK   10

Definition at line 91 of file nmd.c.

Referenced by NMDCreateObject().

#define CHKLEN   500

Referenced by NMDReportObject().

#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");}}

Referenced by NMDReportObject().


Function Documentation

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

NMDErrorCode NMDGetDataType ( NMD_metadata  obj,
char *  cat,
char *  cmp,
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 }

Here is the call graph for this function:

PetscErrorCode NMDGetTypeMySQLName ( NMDDataType  type,
char **  name 
)

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 }

Here is the call graph for this function:

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 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:

  • obj : the metadata object
  • ar : boolean to indicate whether arrays need to be written out in full. If this is false, only the first and last couple of elements are given.
  • rkey : a string containing the names of the metadata items
  • rval : the metadata items
  • delim : delimiter character used in rkey and rval
  • itemdelim1 : an optional opening quote, used for both keys and values. (A NULL value will cause no delimiter to be printed, rather than a null character.) For instance, use the backquote when generating MySQL strings.
  • itemdelim2 : an optional closing quote

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

NMDErrorCode NMDUnsetValue ( NMD_metadata  obj,
const char *  cat,
const char *  cmp 
)

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 }

Here is the call graph for this function:

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 }


Variable Documentation

const char* mysqltypenames[]

Initial value:

  {"VARCHAR(256)","INTEGER","DOUBLE","VARCHAR(1024)",
   "VARCHAR(1024)","VARCHAR(1024)"}

Definition at line 86 of file nmd.c.

Referenced by NMDGetTypeMySQLName().

const int nnmdtypenames = 6 [static]

Definition at line 89 of file nmd.c.

Referenced by NMDGetTypeMySQLName().

const char* typenames[]

Initial value:

  {"invalid","int","real","string","intarray","realarray"}

Definition at line 84 of file nmd.c.


Generated on Sun Oct 4 03:59:26 2009 for NMD by  doxygen 1.5.9