nmd.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define NMD_H   1
#define NMDTrue   1
#define NMDFalse   0
#define NMDCOOKIE   32897432
#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); }
#define NMD_MALLOC(a, b, c, d)
#define NMD_FREE(a)   {free(a);}
#define NMD_STRDUP(a, b)   b = strdup(a);

Typedefs

typedef double NMDRealtype
typedef int NMDTruth
typedef int NMDErrorCode
typedef struct NMD_metadata_item_NMD_metadata_item
typedef struct
NMD_metadata_category_
NMD_metadata_category
typedef struct NMD_metadata_NMD_metadata
typedef struct NMD_object_NMD_object
typedef struct NMD_string_NMD_string

Enumerations

enum  NMDDataType {
  NMDInvalid, NMDInt, NMDReal, NMDString,
  NMDIntarray, NMDRealarray
}

Functions

NMDErrorCode NMDCreateObject (NMD_metadata *)
NMDErrorCode NMDDestroyObject (NMD_metadata)
NMDErrorCode NMDViewObject (NMD_metadata)
NMDErrorCode NMDBuildObjectStructure (NMD_metadata)
NMDErrorCode NMDDestroyObjectStructure (NMD_metadata)
NMDErrorCode NMDCloneObjectStructure (NMD_metadata, NMD_metadata *)
NMDErrorCode NMDCloneObject (NMD_metadata, NMD_metadata)
NMDErrorCode NMDReportObject (NMD_metadata, NMDTruth, char **, char **, char, char, char)
NMDErrorCode NMDObjectAllocateNewCategory (NMD_metadata, const char *, NMD_metadata_category *)
NMDErrorCode NMDObjectTryGetCategory (NMD_metadata, const char *, NMD_metadata_category *, NMDTruth *)
NMDErrorCode NMDObjectGetCategory (NMD_metadata, char *, NMD_metadata_category *)
NMDErrorCode NMDObjectGetOrCreateCategory (NMD_metadata obj, char *cat, NMD_metadata_category *ctg)
NMDErrorCode NMDRemoveCategory (NMD_metadata, const char *)
NMDErrorCode NMDCopyCategory (NMD_metadata_category, NMD_metadata_category)
NMDErrorCode NMDGetCategories (NMD_metadata, int *, char ***)
NMDErrorCode NMDCategoryAllocateNewComponent (NMD_metadata_category, const char *, NMDDataType, NMD_metadata_item *)
NMDErrorCode NMDComponentDestroy (NMD_metadata_item)
NMDErrorCode NMDCategoryCreateComponent (NMD_metadata, char *, char *)
NMDErrorCode NMDCategoryGetComponents (NMD_metadata, char *, int *, char ***, NMDDataType **)
NMDErrorCode NMDCategoryGetOrCreateComponent (NMD_metadata_category, char *, NMDDataType, NMD_metadata_item *)
NMDErrorCode NMDCategoryTryGetComponent (NMD_metadata_category, const char *, NMD_metadata_item *, NMDTruth *)
NMDErrorCode NMDObjectHasCategoryComponent (NMD_metadata, char *, char *, NMDTruth *)
NMDErrorCode NMDObjectEnsureCategoryComponent (NMD_metadata, char *, char *, NMDDataType, NMDTruth *)
NMDErrorCode NMDCategoryGetComponent (NMD_metadata_category, char *, NMD_metadata_item *)
NMDErrorCode NMDGetCategoryIGetComponents (NMD_metadata, int, int *, char ***, NMDDataType **)
NMDErrorCode NMDSetValue (NMD_metadata, const char *, const char *, NMDDataType, void *)
NMDErrorCode NMDComponentSetValue (NMD_metadata_item, NMDDataType, void *)
NMDErrorCode NMDComponentUnsetValue (NMD_metadata_item)
NMDErrorCode NMDSetArrayValue (NMD_metadata, const char *, const char *, NMDDataType, void *, int)
NMDErrorCode NMDComponentSetArrayValue (NMD_metadata_item, NMDDataType, void *, int)
NMDErrorCode NMDCopyArrayValue (NMD_metadata, const char *, const char *, NMDDataType, void *, int)
NMDErrorCode NMDGetValue (NMD_metadata, const char *, const char *, NMDDataType *, void *, NMDTruth *)
NMDErrorCode NMDGetArrayValue (NMD_metadata, char *, char *, NMDDataType *, void *, int *, NMDTruth *)
NMDErrorCode NMDCopyItemValues (NMD_metadata_item, NMD_metadata_item)
NMDErrorCode NMDGetDataType (NMD_metadata, char *, char *, NMDDataType *t)
NMDErrorCode NMDIsArrayType (NMDDataType type, NMDTruth *)
NMDErrorCode NMDUnsetValue (NMD_metadata, const char *, const char *)
PetscErrorCode NMDGetTypeMySQLName (NMDDataType, char **)
NMDErrorCode NMDStringCreate (char *, NMD_string *)
NMDErrorCode NMDStringDestroy (NMD_string)
NMDErrorCode NMDStringGetString (NMD_string str, char **t)
NMDErrorCode NMDStringConcat (char, NMD_string, char, NMD_string, char, NMD_string *)

Variables

const char * typenames []


Define Documentation

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

#define NMD_FREE (  )     {free(a);}

#define NMD_H   1

Definition at line 2 of file nmd.h.

#define NMD_MALLOC ( a,
b,
c,
 ) 

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 = strdup(a);

#define NMDCOOKIE   32897432

#define NMDFalse   0

#define NMDTrue   1


Typedef Documentation

typedef struct NMD_metadata_* NMD_metadata

Definition at line 35 of file nmd.h.

Definition at line 34 of file nmd.h.

Definition at line 33 of file nmd.h.

typedef struct NMD_object_* NMD_object

Definition at line 36 of file nmd.h.

typedef struct NMD_string_* NMD_string

Definition at line 117 of file nmd.h.

typedef int NMDErrorCode

Definition at line 25 of file nmd.h.

typedef double NMDRealtype

Definition at line 21 of file nmd.h.

typedef int NMDTruth

Definition at line 22 of file nmd.h.


Enumeration Type Documentation

Enumerator:
NMDInvalid 
NMDInt 
NMDReal 
NMDString 
NMDIntarray 
NMDRealarray 

Definition at line 28 of file nmd.h.


Function Documentation

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

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

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

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

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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

Here is the call graph for this function:

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 }

Here is the call graph for this function:

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 }

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* typenames[]

Definition at line 84 of file nmd.c.


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