NMD
Defines | Functions | Variables
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(MPI_COMM_WORLD,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, const char **rkey, const char **rval, const char delim, const char itemdelim1, const 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, const char *cat, const char *cmp, NMDDataType *t, void *v, int *len, NMDTruth *f)
NMDErrorCode NMDGetDataType (NMD_metadata obj, const char *cat, const char *cmp, NMDDataType *t)
NMDErrorCode NMDIsArrayType (NMDDataType type, NMDTruth *flg)
PetscErrorCode NMDGetTypeMySQLName (NMDDataType type, const 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(MPI_COMM_WORLD,1,"sprintf would overflow allocated buffer");}}

Referenced by NMDReportObject().


Function Documentation

Given an already created NMD_metadata object, fill it with the data of a template object. See also NMDCloneObjectStructure().

Definition at line 210 of file nmd.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDCategoryGetOrCreateComponent(), NMDCopyItemValues(), NMDObjectGetOrCreateCategory(), and NMD_metadata_item_::t.

Referenced by main().

{
  int icat; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(old);
  CHECKHASNMDCOOKIE(nnew);
  for (icat=0; icat<old->ncat; icat++) {
    /* loop over input categories by index; output categories
       are retrieved by label, or newly created */
    NMD_metadata_category oldcat = old->cats[icat],newcat; int icmp;
    ierr = NMDObjectGetOrCreateCategory
      (nnew,oldcat->name,&newcat); NMD_ERR_RETURN(ierr);
    CHECKHASNMDCOOKIE(oldcat);
    for (icmp=0; icmp<oldcat->ncmp; icmp++) {
      NMD_metadata_item oldcmp = oldcat->cmps[icmp],newcmp;
      ierr = NMDCategoryGetOrCreateComponent
        (newcat,oldcmp->name,oldcmp->t,&newcmp); NMD_ERR_RETURN(ierr);
      ierr = NMDCopyItemValues(oldcmp,newcmp); NMD_ERR_RETURN(ierr);
    }
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

This routine creates an NMD_metadata object, and fills it in with the categories and components of a template object. Data is not copied; for that, see NMDCloneObject() and NMDCopyCategory().

Definition at line 181 of file nmd.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDCreateObject(), NMDObjectEnsureCategoryComponent(), and NMD_metadata_item_::t.

Referenced by main().

{
  NMD_metadata nnew;
  int icat,icmp; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(old);
  ierr = NMDCreateObject(&nnew); NMD_ERR_RETURN(ierr);
  CHECKHASNMDCOOKIE(nnew);
  for (icat=0; icat<old->ncat; icat++) {
    NMD_metadata_category oldcat = old->cats[icat];
    CHECKHASNMDCOOKIE(oldcat);
    for (icmp=0; icmp<oldcat->ncmp; icmp++) {
      NMD_metadata_item oldcmp = oldcat->cmps[icmp];
      CHECKHASNMDCOOKIE(oldcmp);
      ierr = NMDObjectEnsureCategoryComponent
        (nnew,oldcat->name,oldcmp->name,oldcmp->t,NULL); NMD_ERR_RETURN(ierr);
    }
  }
  CHKMEMQ;
  *ret = nnew;
  return 0;
}

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_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::ii, NMD_intarray_struct::length, NMD_realarray_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_intarray_struct::unique, and NMD_realarray_struct::unique.

Referenced by main().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr);
  ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr);

  CHECKHASNMDCOOKIE(cpt);
  cpt->set = NMDTrue;
  switch (cpt->t) {
  case NMDInt :
  case NMDReal :
  case NMDString :
    ierr = NMDSetValue(obj,cat,cmp,t,v); NMD_ERR_RETURN(ierr);
    break;
  case NMDIntarray : {
    struct NMD_intarray_struct* iistruct; int *ii,i;
    NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct");
    iistruct->unique = 1; iistruct->length = l; 
    NMD_MALLOC(ii,l,sizeof(int),"copied int array");
    for (i=0; i<l; i++) ii[i] = (*(int**)v)[i];
    iistruct->data = ii;
    cpt->ii = iistruct;
    break;}
  case NMDRealarray : {
    struct NMD_realarray_struct* rrstruct; NMDRealtype *rr; int i;
    NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct");
    rrstruct->unique = 1; rrstruct->length = l;
    NMD_MALLOC(rr,l,NMDRealtype,"copied real array");
    for (i=0; i<l; i++) rr[i] = (*(NMDRealtype**)v)[i];
    rrstruct->data = rr;
    cpt->rr = rrstruct;
    break;}
  default : NMD_ERR_REPORTi("Unknown type",(int)t); break;
  }
  CHKMEMQ;

  return 0;
}

Here is the call graph for this function:

This routine create an NMD_metadata object, and allocates enough space in it for 10 categories of 20 elements each. Currently this can not be reallocated. In the future we want to be a bit more flexible.

Definition at line 108 of file nmd.c.

References NMD_metadata_::alloc, CATCHUNK, NMD_metadata_::cats, CHKMEMQ, NMD_metadata_::cookie, NMD_metadata_::ncat, NMD_MALLOC, and NMDCOOKIE.

Referenced by main(), and NMDCloneObjectStructure().

{
  NMD_metadata nnew;

  /* allocate the metadata object */
  NMD_MALLOC(nnew,1,struct NMD_metadata_,"object");
  nnew->cookie = NMDCOOKIE;
  *obj = nnew;

  /* give it a basic array of categories */
  nnew->alloc = CATCHUNK; nnew->ncat = 0;
  NMD_MALLOC(nnew->cats,nnew->alloc,NMD_metadata_category,"categories");

  CHKMEMQ;
  return 0;
}

Deallocate all the data in a metadata object.

Definition at line 130 of file nmd.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMD_FREE, and NMDComponentDestroy().

Referenced by main().

{
  int i,j; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  for (i=0; i<obj->ncat; i++) {
    NMD_metadata_category cat = obj->cats[i];
    for (j=0; j<cat->ncmp; j++) {
      NMD_metadata_item cmp = cat->cmps[j];
      ierr = NMDComponentDestroy(cmp); NMD_ERR_RETURN(ierr);
    }
    NMD_FREE(cat->cmps);
    NMD_FREE(cat->name);
    NMD_FREE(cat);
    CHKMEMQ;
  }
  NMD_FREE(obj->cats);
  NMD_FREE(obj);

  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDGetArrayValue ( NMD_metadata  obj,
const char *  cat,
const char *  cmp,
NMDDataType t,
void *  v,
int *  len,
NMDTruth f 
)

Retrieve a stored value. If no value has been stored under the specified category and component, a zero flag is returned. The flag parameter can be null.

Null pointers can be passed for the datatype or value, for instance to test only for the existence of a set value.

See also Value handling.

Definition at line 632 of file nmd.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::ii, NMD_intarray_struct::length, NMD_realarray_struct::length, NMDCategoryGetComponent(), NMDFalse, NMDGetValue(), NMDInt, NMDIntarray, NMDObjectGetCategory(), NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by main().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr);
  CHECKHASNMDCOOKIE(ctg);
  ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr);
  CHECKHASNMDCOOKIE(cpt);
  if (!cpt->set) {
    if (f) {
      *f = NMDFalse; return 0;
    } else NMD_ERR_REPORT
             ("Value not set, but no flag given to report this");
  }
  if (t) *t = cpt->t;
  switch (cpt->t) {
  case NMDInt :
  case NMDReal :
  case NMDString :
    ierr = NMDGetValue(obj,cat,cmp,NULL,v,f); NMD_ERR_RETURN(ierr);
    break;
  case NMDIntarray :
    if (v || len) {
      struct NMD_intarray_struct *as = cpt->ii;
      if (v) *(int**)v = as->data;
      if (len) *len = as->length;
    }
    if (f) *f = NMDTrue; break;
  case NMDRealarray :
    if (v || len) {
      struct NMD_realarray_struct *as = cpt->rr;
      if (v) *(NMDRealtype**)v = as->data;
      if (len) *len = as->length;
    }
    if (f) *f = NMDTrue; break;
  default :
    if (f) *f = NMDFalse;
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDGetDataType ( NMD_metadata  obj,
const char *  cat,
const char *  cmp,
NMDDataType t 
)

Definition at line 720 of file nmd.c.

References CHECKHASNMDCOOKIE, NMDCategoryGetComponent(), NMDObjectGetCategory(), and NMD_metadata_item_::t.

{
  NMD_metadata_category ctg; NMD_metadata_item cpt;
  NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr);
  ierr = NMDCategoryGetComponent(ctg,cmp,&cpt); NMD_ERR_RETURN(ierr);
  CHECKHASNMDCOOKIE(cmp);
  *t = cpt->t;
  
  return 0;
}

Here is the call graph for this function:

PetscErrorCode NMDGetTypeMySQLName ( NMDDataType  type,
const char **  name 
)

Definition at line 745 of file nmd.c.

References mysqltypenames, and nnmdtypenames.

Referenced by main().

{
  int itype = (int)(type);
  if (itype<0 || itype>=nnmdtypenames)
    NMD_ERR_REPORTi("Invalid type",itype);
  *name = (char*)mysqltypenames[itype];
  return 0;
}
NMDErrorCode NMDGetValue ( NMD_metadata  obj,
const char *  cat,
const char *  cmp,
NMDDataType t,
void *  v,
NMDTruth f 
)

Retrieve a stored scalar value. If no value has been stored under the specified category and component, a zero flag is returned. The flag parameter can be null.

Null pointers can be passed for the datatype or value, for instance to test only for the existence of a set value.

See also Value handling.

Definition at line 571 of file nmd.c.

References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_item_::i, NMDCategoryTryGetComponent(), NMDFalse, NMDInt, NMDIntarray, NMDObjectTryGetCategory(), NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by main(), NMDGetArrayValue(), and NMDTabReportData().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; 
  NMDTruth ff; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&ff); NMD_ERR_RETURN(ierr);
  if (!ff) {
    if (f) {
      *f = NMDFalse; return 0;
    } else NMD_ERR_REPORT
             ("Could not find category, but no flag given to report this");
  }
  CHECKHASNMDCOOKIE(ctg);
  ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&ff); NMD_ERR_RETURN(ierr);
  if (!ff) {
    if (f) {
      *f = NMDFalse; return 0;
    } else NMD_ERR_REPORT
             ("Could not find component, but no flag given to report this");
  }
  CHECKHASNMDCOOKIE(cpt);
  if (!cpt->set) {
    if (f) {
      *f = NMDFalse; return 0;
    } else NMD_ERR_REPORT
             ("Value not set, but no flag given to report this");
  }
  if (t) *t = cpt->t;
  switch (cpt->t) {
  case NMDInt :
    if (v) *(int*)v = cpt->i;
    if (f) *f = NMDTrue; break;
  case NMDReal :
    if (v) *(double*)v = cpt->r;
    if (f) *f = NMDTrue; break;
  case NMDString :
    if (v) *(char**)v = cpt->cc;
    if (f) *f = NMDTrue; break;
  case NMDIntarray :
  case NMDRealarray :
    NMD_ERR_REPORT("Please use NMDGetArrayValue"); break;
  default :
    if (f) *f = NMDFalse;
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

Test whether a data type is an array type

Definition at line 737 of file nmd.c.

References NMDFalse, NMDIntarray, NMDRealarray, and NMDTrue.

Referenced by main().

{
  *flg = ( (type==NMDIntarray) || (type==NMDRealarray) ? NMDTrue : NMDFalse ) ;
  return 0;
}
NMDErrorCode NMDReportObject ( NMD_metadata  obj,
NMDTruth  arrays,
const char **  rkey,
const char **  rval,
const char  delim,
const char  itemdelim1,
const char  itemdelim2 
)

Generate a delimited representation of a metadata object.

The returned strings are allocated in this routine and it is the user's responsibility to free them with NMD_FREE().

Arguments:

  • 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_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::i, NMD_metadata_item_::ii, NMD_intarray_struct::length, NMD_realarray_struct::length, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMD_FREE, NMD_MALLOC, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMD_metadata_item_::r, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by main().

{
  int icat,icmp,write,keylen=0,vallen=0; char *key=NULL,*val=NULL, *scratch;
  CHECKHASNMDCOOKIE(obj);

  /*
   * allocate and fill in the key and value strings
   */
#define CHKLEN 500
  NMD_MALLOC(scratch,CHKLEN,char,"scratch pad");
#define CHKSPACEFOR(ar,arlen,fmt,str) {int nr; memset(scratch,0,CHKLEN); sprintf(scratch,fmt,str); nr=strlen(scratch); if (write==0) {arlen = arlen+nr+2; } else {int l = strlen(ar); if (l+nr<arlen) {sprintf(ar+l,fmt,str);} else SETERRQ(MPI_COMM_WORLD,1,"sprintf would overflow allocated buffer");}}
  write = 0;
 writeloop:
  if (write==0) {
    keylen=vallen=0;
  } else {
    if (rkey) NMD_MALLOC(key,keylen,char,"names array");
    if (rval) NMD_MALLOC(val,vallen,char,"values array");
  }
  for (icat=0; icat<obj->ncat; icat++) {
    NMD_metadata_category cat = obj->cats[icat];
    CHECKHASNMDCOOKIE(cat);
    for (icmp=0; icmp<cat->ncmp; icmp++) {
      NMD_metadata_item cmp = cat->cmps[icmp];
      CHECKHASNMDCOOKIE(cmp);
      if (rkey) {
        if (itemdelim1) CHKSPACEFOR(key,keylen,"%c",itemdelim1);
        CHKSPACEFOR(key,keylen,"%s:",cat->name);
        CHKSPACEFOR(key,keylen,"%s",cmp->name);
        if (itemdelim2) CHKSPACEFOR(key,keylen,"%c",itemdelim2);
        CHKSPACEFOR(key,keylen,"%c",delim);
      }
      if (rval) {
        if (itemdelim1) CHKSPACEFOR(val,vallen,"%c",itemdelim1);
        if (!cmp->set) goto delimiter;
        switch (cmp->t) {
        case NMDInt : {
          CHKSPACEFOR(val,vallen,"%8d",cmp->i); break;}
        case NMDReal : {
          CHKSPACEFOR(val,vallen,"%15.8e",cmp->r); break;}
        case NMDString :
          if (!cmp->cc) NMD_ERR_REPORT("Null string");
          if (strlen(cmp->cc)>0) {
            if (strlen(cmp->cc)<=CHKLEN) {
              CHKSPACEFOR(val,vallen,"%s",cmp->cc);
            } else {CHKSPACEFOR(val,vallen,"%s","stringtoolong");}
          } else {
            CHKSPACEFOR(val,vallen,"%s","null"); 
          }
          break;
        case NMDIntarray : {
          struct NMD_intarray_struct *arraystruct =
            (struct NMD_intarray_struct *)(cmp->ii);
          int n = arraystruct->length,i;
          if (arrays || n<=4) {
            for (i=0; i<n; i++) {
              if (i<n-1) {
                CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[i]);
              } else {
                CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[i]);
              }
            }
          } else {
            CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[0]);
            CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[1]);
            CHKSPACEFOR(val,vallen,"%8d,",arraystruct->data[n-2]);
            CHKSPACEFOR(val,vallen,"%8d",arraystruct->data[n-1]);
          }
        } ; break;
        case NMDRealarray : {
          struct NMD_realarray_struct *arraystruct =
            (struct NMD_realarray_struct *)(cmp->rr);
          int n = arraystruct->length,i;
          if (arrays || n<=4) {
            for (i=0; i<n; i++) {
              if (i<n-1) {
                CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[i]);
              } else {
                CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[i]);
              }
            }
          } else {
            CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[0]);
            CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[1]);
            CHKSPACEFOR(val,vallen,"%11.4e,",arraystruct->data[n-2]);
            CHKSPACEFOR(val,vallen,"%11.4e",arraystruct->data[n-1]);
          }
        } ; break;
        default :
          CHKSPACEFOR(val,vallen,"%s","==="); break;
        }
      delimiter:
        if (itemdelim2) CHKSPACEFOR(val,vallen,"%c",itemdelim2);
        CHKSPACEFOR(val,vallen,"%c",delim);
      }
    }
  }
  write += 1;
  if (write<=1) goto writeloop;
  NMD_FREE(scratch);
  CHKMEMQ;
  /* *rkey = key; *rval = val; */
  if (key) {
    int l = strlen(key); 
    if (l>keylen)
      NMD_ERR_REPORT("key string overrun");
    *rkey = key;
  }
  if (val) {
    int l = strlen(val); 
    if (l>vallen)
      NMD_ERR_REPORTii("val string overrun; alloc/actual",vallen,l);
    *rval = val;
  }

  return 0;
}
NMDErrorCode NMDSetArrayValue ( NMD_metadata  obj,
const char *  cat,
const char *  cmp,
NMDDataType  t,
void *  v,
int  l 
)

Set a metadata value, if it is an array type.

The arrays are not copied, so the user is responsible for freeing the array. Use NMDCopyArrayValue() to have the array copied; NMD will then free the array when the metadata object is freed.

This call can be used to create categories and components; there is no checking of slight misspellings.

See also Value handling.

Definition at line 494 of file nmd.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryGetOrCreateComponent(), NMDComponentSetArrayValue(), and NMDObjectGetOrCreateCategory().

Referenced by main().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr);
  ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr);
  ierr = NMDComponentSetArrayValue(cpt,t,v,l); NMD_ERR_RETURN(ierr);
  CHKMEMQ;

  return 0;
}

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().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetOrCreateCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr);
  ierr = NMDCategoryGetOrCreateComponent(ctg,(char*)cmp,t,&cpt); NMD_ERR_RETURN(ierr);
  ierr = NMDComponentSetValue(cpt,t,v); NMD_ERR_RETURN(ierr);
  CHKMEMQ;

  return 0;
}

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().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt; 
  NMDTruth flg; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) return 0;
  ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) return 0;
  ierr = NMDComponentUnsetValue(cpt); NMD_ERR_RETURN(ierr);
  CHKMEMQ;

  return 0;
}

Here is the call graph for this function:

Print out an NMD object.

Currently only int, real, string fields are displayed, others are displayed as "***".

Definition at line 245 of file nmd.c.

References NMD_metadata_::cats, NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::i, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDInt, NMDReal, NMDString, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.

{
  int icat,icmp;
  CHECKHASNMDCOOKIE(obj);
  printf("========\n");
  for (icat=0; icat<obj->ncat; icat++) {
    NMD_metadata_category cat = obj->cats[icat];
    CHECKHASNMDCOOKIE(cat);
    printf("Category: <%s>\n",cat->name);
    for (icmp=0; icmp<cat->ncmp; icmp++) {
      NMD_metadata_item cmp = cat->cmps[icmp];
      CHECKHASNMDCOOKIE(cmp);
      printf("  <%s> : ",cmp->name);
      if (!cmp->set) {
        printf("(null)\n");
      } else {
        switch (cmp->t) {
        case NMDInt : printf("<%d>\n",cmp->i); break;
        case NMDReal : printf("<%e>\n",cmp->r); break;
        case NMDString : printf("<<%s>>\n",cmp->cc); break;
        default : printf("****\n"); break;
        }
      }
    }
  }
  printf("========\n\n");
  CHKMEMQ;
  return 0;
}

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.