NMD
Defines | Typedefs | Enumerations | Functions | Variables
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 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, const char **, const char **, const char, const char, const char)
NMDErrorCode NMDObjectAllocateNewCategory (NMD_metadata, const char *, NMD_metadata_category *)
NMDErrorCode NMDObjectTryGetCategory (NMD_metadata, const char *, NMD_metadata_category *, NMDTruth *)
NMDErrorCode NMDObjectGetCategory (NMD_metadata, const char *, NMD_metadata_category *)
NMDErrorCode NMDObjectGetOrCreateCategory (NMD_metadata obj, const 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, const char *, int *, const char ***, NMDDataType **)
NMDErrorCode NMDCategoryGetOrCreateComponent (NMD_metadata_category, const char *, NMDDataType, NMD_metadata_item *)
NMDErrorCode NMDCategoryTryGetComponent (NMD_metadata_category, const char *, NMD_metadata_item *, NMDTruth *)
NMDErrorCode NMDObjectHasCategoryComponent (NMD_metadata, const char *, const char *, NMDTruth *)
NMDErrorCode NMDObjectEnsureCategoryComponent (NMD_metadata, const char *, const char *, NMDDataType, NMDTruth *)
NMDErrorCode NMDCategoryGetComponent (NMD_metadata_category, const 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, const char *, const char *, NMDDataType *, void *, int *, NMDTruth *)
NMDErrorCode NMDCopyItemValues (NMD_metadata_item, NMD_metadata_item)
NMDErrorCode NMDGetDataType (NMD_metadata, const char *, const char *, NMDDataType *t)
NMDErrorCode NMDIsArrayType (NMDDataType type, NMDTruth *)
NMDErrorCode NMDUnsetValue (NMD_metadata, const char *, const char *)
NMDErrorCode NMDGetTypeMySQLName (NMDDataType, const char **)
NMDErrorCode NMDObjectDumpToMySQL (NMD_metadata obj)
NMDErrorCode NMDStringCreate (const char *, NMD_string *)
NMDErrorCode NMDStringDestroy (NMD_string)
NMDErrorCode NMDStringGetString (NMD_string str, const char **t)
NMDErrorCode NMDStringConcat (char, NMD_string, char, NMD_string, char, NMD_string *)
NMDErrorCode NMDStringAppend (char, NMD_string *, char, NMD_string, char)

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 (   a)    {free(a);}
#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 141 of file nmd.h.

Referenced by main(), NMDAllocateCategory(), NMDAllocateComponent(), NMDCategoryGetComponents(), NMDComponentSetArrayValue(), NMDCopyArrayValue(), NMDCopyItemValues(), NMDCreateObject(), NMDGetCategories(), NMDGetCategoryIGetComponents(), NMDReportObject(), NMDStringCreateOfSize(), and NMDTabReportData().

#define NMD_STRDUP (   a,
 
)    b = 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 119 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

Create a new component by name in an existing category object. If a component pointer is supplied, the new component object is returned, but this pointer is allowed to be NULL.

Definition at line 41 of file nmdcmp.c.

References NMD_metadata_category_::alloc, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_STRDUP, NMDAllocateComponent(), NMDFalse, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by main(), NMDCategoryGetOrCreateComponent(), and NMDObjectEnsureCategoryComponent().

{
  NMD_metadata_item cpt; int idx; NMDErrorCode ierr;
  /*
   * if we are about to overflow, 
   * reallocate the components in this category
   */
  if (cat->ncmp >= cat->alloc) {
    NMD_metadata_item* newcmps; int newalloc;
    newalloc = 2*cat->alloc;
    ierr = PetscMalloc
      (newalloc*sizeof(struct NMD_metadata_item_),&newcmps); CHKERRQ(ierr);
    for (idx=0; idx<cat->ncmp; idx++)
      newcmps[idx] = cat->cmps[idx];
    ierr = PetscFree(cat->cmps); CHKERRQ(ierr);
    cat->cmps = newcmps; cat->alloc = newalloc;
  }
  /*
   * with space guaranteed, create the component
   */
  idx = cat->ncmp++;
  ierr = NMDAllocateComponent(&cpt); NMD_ERR_RETURN(ierr);
  NMD_STRDUP(cmp,cpt->name); cpt->t = type; cpt->set = NMDFalse;
  cat->cmps[idx] = cpt;
  if (rcpt) *rcpt = cpt;
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDCategoryCreateComponent ( NMD_metadata  ,
char *  ,
char *   
)

Test whether a metadata category has a certain component. The component has to exist.

Definition at line 234 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, and NMDCategoryTryGetComponent().

Referenced by NMDGetArrayValue(), and NMDGetDataType().

{
  NMDTruth flg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(cat);
  ierr = NMDCategoryTryGetComponent
    (cat,cmp,cpt,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) NMD_ERR_REPORTss("Could not find component in category",cmp,cat->name);
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDCategoryGetComponents ( NMD_metadata  obj,
const char *  cat,
int *  ncmp,
const char ***  cmps,
NMDDataType **  typs 
)

Get a list of all component names and types in a category. All three output arguments are optional. The names and types arrays are allocated and should be freed by the user by NMD_FREE(). The names in the name array points to the strings in the database object, so they do not need to be freed.

Definition at line 205 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_MALLOC, NMDObjectGetCategory(), and NMD_metadata_item_::t.

Referenced by main().

{
  NMD_metadata_category catobj; int icmp; 
  const char **names; NMDDataType *types; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetCategory(obj,cat,&catobj); CHKERRQ(ierr);
  if (ncmp) *ncmp = catobj->ncmp;
  if (cmps) {
    NMD_MALLOC(names,catobj->ncmp,char*,"name array");
    for (icmp=0; icmp<catobj->ncmp; icmp++)
      names[icmp] = catobj->cmps[icmp]->name;
    *cmps = names;
  }
  if (typs) {
    NMD_MALLOC(types,catobj->ncmp,NMDDataType,"type array");
    for (icmp=0; icmp<catobj->ncmp; icmp++)
      types[icmp] = catobj->cmps[icmp]->t;
    *typs = types;
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

Retrieve a component, creating it if it doesn't already exist.

Definition at line 108 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryAllocateNewComponent(), NMDCategoryTryGetComponent(), and NMD_metadata_item_::t.

Referenced by main(), NMDCloneObject(), NMDCopyArrayValue(), NMDCopyCategory(), NMDSetArrayValue(), and NMDSetValue().

{
  NMD_metadata_item cnew; NMDTruth flg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(cat);
  ierr = NMDCategoryTryGetComponent(cat,cmp,&cnew,&flg); NMD_ERR_RETURN(ierr);
  if (flg) {
    if (type!=cnew->t)
      NMD_ERR_REPORTii
        ("Type incompatibility: old/new",(int)(cnew->t),(int)type);
    if (cpt) *cpt = cnew;
  } else {
    ierr = NMDCategoryAllocateNewComponent
      (cat,cmp,type,cpt); NMD_ERR_RETURN(ierr);
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

Test whether a metadata category has a certain component.

Definition at line 178 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMDFalse, and NMDTrue.

Referenced by main(), NMDCategoryGetComponent(), NMDCategoryGetOrCreateComponent(), NMDGetValue(), NMDObjectEnsureCategoryComponent(), NMDObjectHasCategoryComponent(), and NMDUnsetValue().

{
  int icmp;
  CHECKHASNMDCOOKIE(cat);
  *f = NMDFalse;
  for (icmp=0; icmp<cat->ncmp; icmp++) {
    NMD_metadata_item cpt = cat->cmps[icmp];
    CHECKHASNMDCOOKIE(cpt);
    if (strcmp(cmp,cpt->name)==0) {
      *f = NMDTrue;
      if (rcpt) *rcpt = cpt;
      break;
    }
  }
  CHKMEMQ;
  return 0;
}

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:

Definition at line 72 of file nmdcmp.c.

References NMD_metadata_item_::cc, NMD_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::ii, NMD_intarray_struct::length, NMD_realarray_struct::length, NMD_metadata_item_::name, NMD_FREE, NMDIntarray, NMDRealarray, NMDString, NMD_metadata_item_::rr, NMD_metadata_item_::t, NMD_intarray_struct::unique, and NMD_realarray_struct::unique.

Referenced by NMDDestroyObject().

{
  switch (cmp->t) {
  case NMDIntarray :
    if (cmp->ii) {
      struct NMD_intarray_struct *arraystruct =
        (struct NMD_intarray_struct *)(cmp->ii);
      if (arraystruct->length>0 && arraystruct->unique==1)
        NMD_FREE(arraystruct->data);
      NMD_FREE(cmp->ii);
    } ; 
    break;
  case NMDRealarray :
    if (cmp->rr) {
      struct NMD_realarray_struct *arraystruct =
        (struct NMD_realarray_struct *)(cmp->rr);
      if (arraystruct->length>0 && arraystruct->unique==1)
        NMD_FREE(arraystruct->data);
      NMD_FREE(cmp->rr);
    } ;
    break;
  case NMDString : NMD_FREE(cmp->cc);
    break;
  default : /* other components need no destructor */
    break;
  }
  NMD_FREE(cmp->name);
  NMD_FREE(cmp);
  return 0;
}

Definition at line 323 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, NMD_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::ii, NMD_intarray_struct::length, NMD_realarray_struct::length, NMD_MALLOC, NMDComponentSetValue(), NMDInt, NMDIntarray, NMDReal, NMDRealarray, 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 NMDSetArrayValue().

{
  NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(cpt);
  switch (cpt->t) {
  case NMDInt : 
  case NMDReal : 
  case NMDString : 
    ierr = NMDComponentSetValue(cpt,cpt->t,v); NMD_ERR_RETURN(ierr);
    break;
  case NMDIntarray : {
    struct NMD_intarray_struct* iistruct;
    NMD_MALLOC(iistruct,1,struct NMD_intarray_struct,"int array struct");
    iistruct->unique = 0; iistruct->length = l;
    iistruct->data = *(int**)v;
    cpt->ii = iistruct;
    break;}
  case NMDRealarray : {
    struct NMD_realarray_struct* rrstruct;
    NMD_MALLOC(rrstruct,1,struct NMD_realarray_struct,"real array struct");
    rrstruct->unique = 0; rrstruct->length = l;
    rrstruct->data = *(NMDRealtype**)v;
    cpt->rr = rrstruct;
    break;}
  default :
    NMD_ERR_REPORTi("Unknown type",(int)t)
  }
  cpt->set = NMDTrue;
  return 0;
}

Here is the call graph for this function:

Definition at line 278 of file nmdcmp.c.

References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, NMD_metadata_item_::i, NMD_STRDUP, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMDTrue, NMD_metadata_item_::r, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by NMDComponentSetArrayValue(), and NMDSetValue().

{
  CHECKHASNMDCOOKIE(cpt);
  if (t!=cpt->t) NMD_ERR_REPORT("Type conflict");
  switch (cpt->t) {
  case NMDInt : cpt->i = *(int*)v; break;
  case NMDReal : cpt->r = *(double*)v; break;
  case NMDString : NMD_STRDUP((char*)v,cpt->cc); break;
  case NMDIntarray : 
  case NMDRealarray :
    NMD_ERR_REPORT("Please use NMDSetArrayValue"); break;
  default : NMD_ERR_REPORTi("Unknown type",(int)t); break;
  }
  cpt->set = NMDTrue;
  return 0;
}

Definition at line 297 of file nmdcmp.c.

References NMD_metadata_item_::cc, CHECKHASNMDCOOKIE, NMD_intarray_struct::data, NMD_realarray_struct::data, NMD_metadata_item_::ii, NMD_FREE, NMDFalse, NMDInt, NMDIntarray, NMDReal, NMDRealarray, NMDString, NMD_metadata_item_::rr, NMD_metadata_item_::set, and NMD_metadata_item_::t.

Referenced by NMDUnsetValue().

{
  CHECKHASNMDCOOKIE(cpt);
  switch (cpt->t) {
  case NMDInt :
  case NMDReal : break;
  case NMDString : NMD_FREE(cpt->cc); break;
  case NMDIntarray : {
    struct NMD_intarray_struct* iistruct = cpt->ii;
    NMD_FREE(iistruct->data);
    NMD_FREE(iistruct);
    break;}
  case NMDRealarray : {
    struct NMD_realarray_struct* rrstruct = cpt->rr;
    NMD_FREE(rrstruct->data);
    NMD_FREE(rrstruct);
    break;}
  default : NMD_ERR_REPORTi("Unknown type",cpt->t); break;
  }
  cpt->set = NMDFalse;
  return 0;
}
NMDErrorCode NMDCopyArrayValue ( NMD_metadata  obj,
const char *  cat,
const char *  cmp,
NMDDataType  t,
void *  v,
int  l 
)

Set a metadata array value; the user array is copied.

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

See also Value handling.

Definition at line 518 of file nmd.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_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:

Copy category data from one metadata structure into another. This assumes that the category already exists in the target; see for instance NMDHasCategory(), NMDCloneObject(), NMDCloneObjectStructure().

Definition at line 180 of file nmdcat.c.

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

{
  int icmp; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(incat);
  CHECKHASNMDCOOKIE(outcat);

  for (icmp=0; icmp<incat->ncmp; icmp++) {
    NMD_metadata_item src = incat->cmps[icmp],tar;
    ierr = NMDCategoryGetOrCreateComponent
      (outcat,src->name,src->t,&tar); NMD_ERR_RETURN(ierr);
    ierr = NMDCopyItemValues(src,tar); NMD_ERR_RETURN(ierr);
  }
  CHKMEMQ;

  return 0;
}

Here is the call graph for this function:

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

Referenced by NMDCloneObject(), and NMDCopyCategory().

{
  tar->set = src->set; if (!src->set) goto done;
  switch (src->t) {
  case NMDInt : tar->i = src->i; break;
  case NMDReal : tar->r = src->r ; break;
  case NMDString : NMD_STRDUP(src->cc,tar->cc); break;
  case NMDIntarray :
    {
      struct NMD_intarray_struct *tarstruct,*srcstruct = src->ii;
      int length=srcstruct->length;
      NMD_MALLOC(tarstruct,1,struct NMD_intarray_struct,"copied int array");
      tarstruct->length = length; tarstruct->unique = srcstruct->unique;
      if (srcstruct->unique) {
        int *a1=srcstruct->data,*a2; int i;
        NMD_MALLOC(a2,length,int,"int array data");
        for (i=0; i<length; i++) a2[i] = a1[i];
        tarstruct->data = a2;
      } else
        tarstruct->data = srcstruct->data;
      tar->ii = tarstruct;
    } ;
    break;
  case NMDRealarray :
    {
      struct NMD_realarray_struct *tarstruct,*srcstruct = src->rr;
      int length=srcstruct->length;
      NMD_MALLOC(tarstruct,1,struct NMD_realarray_struct,"copied real array");
      tarstruct->length = length; tarstruct->unique = srcstruct->unique;
      if (srcstruct->unique) {
        NMDRealtype *a1=srcstruct->data,*a2; int i;
        NMD_MALLOC(a2,length,NMDRealtype,"real array data");
        for (i=0; i<length; i++) a2[i] = a1[i];
        tarstruct->data = a2;
      } else
        tarstruct->data = srcstruct->data;
      tar->rr = tarstruct;
    } ;
    break;
  default : NMD_ERR_REPORTi("Can not copy items of type",(int)(src->t));
    break;
  }
 done:
  CHKMEMQ;
  return 0;
}

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 NMDGetCategories ( NMD_metadata  obj,
int *  ncat,
char ***  cats 
)

Get the number of categories and their names. Both arguments can be NULL. The names array is allocated; the user needs to free it. The names themselves are pointers to the strings in the metadata object, so they do not need to be freed.

Definition at line 137 of file nmdcat.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, NMD_metadata_::ncat, and NMD_MALLOC.

Referenced by main(), and NMDTabReportData().

{
  CHECKHASNMDCOOKIE(obj);
  if (ncat) *ncat = obj->ncat;
  if (obj->ncat && cats) {
    char **names; int icat;
    NMD_MALLOC(names,obj->ncat,char*,"name array");
    for (icat=0; icat<obj->ncat; icat++)
      names[icat] = obj->cats[icat]->name;
    *cats = names;
  }
  CHKMEMQ;
  return 0;
}
NMDErrorCode NMDGetCategoryIGetComponents ( NMD_metadata  obj,
int  icat,
int *  ncmp,
char ***  cmps,
NMDDataType **  typs 
)

For a given category, get the number of components and their names.

All output arguments can be NULL. The names array is allocated; the user needs to free it. The names themselves are pointers to the strings in the metadata object, so they do not need to be freed. The types array is also allocated and needs to be freed.

Definition at line 255 of file nmdcmp.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, NMD_metadata_category_::cmps, NMD_metadata_item_::name, NMD_metadata_category_::ncmp, NMD_MALLOC, and NMD_metadata_item_::t.

{
  NMD_metadata_category cat;
  CHECKHASNMDCOOKIE(obj);
  cat = obj->cats[icat];
  if (ncmp) *ncmp = cat->ncmp;
  if (cat->ncmp && (cmps || typs) ) {
    NMDDataType *types; char **names; int icmp;
    if (cmps)
      NMD_MALLOC(names,cat->ncmp,char*,"name array");
    if (typs)
      NMD_MALLOC(types,cat->ncmp,NMDDataType,"name array");
    for (icmp=0; icmp<cat->ncmp; icmp++) {
      if (cmps) names[icmp] = cat->cmps[icmp]->name;
      if (typs) types[icmp] = cat->cmps[icmp]->t;
    }
    if (cmps) *cmps = names; if (typs) *typs = types;
  }
  return 0;
}
NMDErrorCode NMDGetDataType ( NMD_metadata  ,
const char *  ,
const char *  ,
NMDDataType t 
)

Definition at line 720 of file nmd.c.

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

{
  NMD_metadata_category ctg; NMD_metadata_item cpt;
  NMDErrorCode ierr;

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

Here is the call graph for this function:

NMDErrorCode NMDGetTypeMySQLName ( NMDDataType  ,
const char **   
)

Definition at line 745 of file nmd.c.

References mysqltypenames, and nnmdtypenames.

Referenced by main().

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

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

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

See also Value handling.

Definition at line 571 of file nmd.c.

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

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

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

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

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

Allocate a category in a metadata object. There is no testing whether the category name is already in use.

If a category pointer is supplied, the category is returned, but this pointer is allowed to be null.

Definition at line 84 of file nmdcat.c.

References NMD_metadata_::alloc, NMD_metadata_::cats, CHKMEMQ, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_STRDUP, and NMDAllocateCategory().

Referenced by main(), NMDObjectEnsureCategoryComponent(), and NMDObjectGetOrCreateCategory().

{
  NMD_metadata_category ctg; int idx; NMDErrorCode ierr;
  /*
   * if we are about to overflow, reallocate 
   */
  if (obj->ncat >= obj->alloc) {
    NMD_metadata_category* newcats; int newalloc;
    newalloc = 2*obj->alloc;
    ierr = PetscMalloc
      (newalloc*sizeof(struct NMD_metadata_category_),&newcats); CHKERRQ(ierr);
    for (idx=0; idx<obj->ncat; idx++)
      newcats[idx] = obj->cats[idx];
    ierr = PetscFree(obj->cats); CHKERRQ(ierr);
    obj->cats = newcats; obj->alloc = newalloc;
  }
  /*
   * with space guaranteed, create the category
   */
  idx = obj->ncat++;
  ierr = NMDAllocateCategory(&ctg); NMD_ERR_RETURN(ierr);
  NMD_STRDUP(cat,ctg->name);
  obj->cats[idx] = ctg;
  if (rctg) *rctg = ctg;
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

Generate an mysql dump of an object

Definition at line 11 of file nmdmysql.c.

References NMD_metadata_::cats, CHECKHASNMDCOOKIE, NMD_metadata_category_::cmps, NMD_metadata_item_::i, NMD_metadata_item_::name, NMD_metadata_category_::name, NMD_metadata_::ncat, NMD_metadata_category_::ncmp, NMDInt, NMDReal, NMDStringAppend(), NMDStringConcat(), NMDStringCreate(), NMDStringDestroy(), NMDStringGetString(), NMD_metadata_item_::r, and NMD_metadata_item_::t.

{
  NMD_string namesstring,valuesstring;
  int icat,icmp; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);

  ierr = NMDStringCreate("",&namesstring); NMD_ERR_RETURN(ierr);
  ierr = NMDStringCreate("",&valuesstring); NMD_ERR_RETURN(ierr);

  for (icat=0; icat<obj->ncat; icat++) {
    NMD_metadata_category cat = obj->cats[icat];
    NMD_string catstring;
    CHECKHASNMDCOOKIE(cat);
    ierr = NMDStringCreate(cat->name,&catstring); NMD_ERR_RETURN(ierr);
    for (icmp=0; icmp<cat->ncmp; icmp++) {
      char cmpvalue[45];
      NMD_metadata_item cmp = cat->cmps[icmp];
      CHECKHASNMDCOOKIE(cmp);
      memset(cmpvalue,0,45);
      switch (cmp->t) {
      case NMDInt : sprintf(cmpvalue,"%d",cmp->i); break;
      case NMDReal : sprintf(cmpvalue,"%e",cmp->r); break;
      default :
        continue;
      }
      if (cmpvalue[0]) {
        NMD_string cmpstring,cmpcatstring;
        /* name */
        ierr = NMDStringCreate(cmp->name,&cmpstring); NMD_ERR_RETURN(ierr);
        ierr = NMDStringConcat
          (0,catstring,':',cmpstring,0,&cmpcatstring); NMD_ERR_RETURN(ierr);
        ierr = NMDStringAppend
          (0,&namesstring,0,cmpcatstring,','); NMD_ERR_RETURN(ierr);
        ierr = NMDStringDestroy(cmpstring); NMD_ERR_RETURN(ierr);
        ierr = NMDStringDestroy(cmpcatstring); NMD_ERR_RETURN(ierr);
        /* value */
        ierr = NMDStringCreate(cmpvalue,&cmpcatstring); NMD_ERR_RETURN(ierr);
        ierr = NMDStringAppend
          (0,&valuesstring,0,cmpcatstring,','); NMD_ERR_RETURN(ierr);
        ierr = NMDStringDestroy(cmpcatstring); NMD_ERR_RETURN(ierr);
      }
    }
    ierr = NMDStringDestroy(catstring); NMD_ERR_RETURN(ierr);
  }

  {
    const char *c;
    ierr = NMDStringGetString(namesstring,&c); NMD_ERR_RETURN(ierr);
    printf("INSERT INTO yourtable (%s)\n",c);
    ierr = NMDStringGetString(valuesstring,&c); NMD_ERR_RETURN(ierr);
    printf("VALUES (%s);\n",c);
  }

  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDObjectEnsureCategoryComponent ( NMD_metadata  ,
const char *  ,
const char *  ,
NMDDataType  ,
NMDTruth  
)

Definition at line 134 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryAllocateNewComponent(), NMDCategoryTryGetComponent(), NMDFalse, NMDObjectAllocateNewCategory(), NMDObjectTryGetCategory(), NMDTrue, and NMD_metadata_item_::t.

Referenced by main(), and NMDCloneObjectStructure().

{
  NMD_metadata_category ctg; NMD_metadata_item cpt;
  NMDTruth flg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,&ctg,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) {
    ierr = NMDObjectAllocateNewCategory(obj,cat,&ctg); NMD_ERR_RETURN(ierr);
  }
  ierr = NMDCategoryTryGetComponent(ctg,cmp,&cpt,&flg); NMD_ERR_RETURN(ierr);
  if (flg) {
    if (nnew) *nnew = NMDFalse;
    if (type!=cpt->t)
      NMD_ERR_REPORTii
        ("Type incompatibility: old/new",(int)(cpt->t),(int)type);
  } else {
    if (nnew) *nnew = NMDTrue;
    ierr = NMDCategoryAllocateNewComponent
      (ctg,cmp,type,NULL); NMD_ERR_RETURN(ierr);
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDObjectGetCategory ( NMD_metadata  obj,
const char *  cat,
NMD_metadata_category ctg 
)

Retrieve a category from a metadata object. The category has to exist.

Definition at line 49 of file nmdcat.c.

References CHECKHASNMDCOOKIE, and NMDObjectTryGetCategory().

Referenced by NMDCategoryGetComponents(), NMDGetArrayValue(), NMDGetDataType(), and NMDRemoveCategory().

{
  NMDTruth flg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) NMD_ERR_REPORTs("Category not found",cat);
  return 0;
}

Here is the call graph for this function:

Retrieve a category from a metadata object, or create it if it doesn't exist yet.

Definition at line 118 of file nmdcat.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDObjectAllocateNewCategory(), and NMDObjectTryGetCategory().

Referenced by NMDCloneObject(), NMDCopyArrayValue(), NMDSetArrayValue(), and NMDSetValue().

{
  NMDTruth flg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,ctg,&flg); NMD_ERR_RETURN(ierr);
  if (!flg) {
    ierr = NMDObjectAllocateNewCategory(obj,cat,ctg); NMD_ERR_RETURN(ierr);
  }
  CHKMEMQ;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDObjectHasCategoryComponent ( NMD_metadata  ,
const char *  ,
const char *  ,
NMDTruth  
)

Definition at line 161 of file nmdcmp.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), and NMDObjectTryGetCategory().

Referenced by main().

{
  NMD_metadata_category ctg; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectTryGetCategory(obj,cat,&ctg,f); NMD_ERR_RETURN(ierr);
  if (*f) {
    ierr = NMDCategoryTryGetComponent(ctg,cmp,NULL,f); NMD_ERR_RETURN(ierr);
  }
  CHKMEMQ;
  return 0;
}

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

{
  int icat;
  CHECKHASNMDCOOKIE(obj);
  *f = NMDFalse;
  for (icat=0; icat<obj->ncat; icat++) {
    NMD_metadata_category ctg = obj->cats[icat];
    CHECKHASNMDCOOKIE(ctg);
    if (strcmp(cat,ctg->name)==0) {
      if (rctg) *rctg = ctg; *f = NMDTrue; break;
    }
  }
  return 0;
}
NMDErrorCode NMDRemoveCategory ( NMD_metadata  ,
const char *   
)

Definition at line 160 of file nmdcat.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMD_metadata_category_::name, NMD_FREE, NMD_STRDUP, and NMDObjectGetCategory().

Referenced by main().

{
  NMD_metadata_category ctg; NMDErrorCode ierr;

  CHECKHASNMDCOOKIE(obj);
  ierr = NMDObjectGetCategory(obj,(char*)cat,&ctg); NMD_ERR_RETURN(ierr);
  NMD_FREE(ctg->name);
  NMD_STRDUP("invalid",ctg->name);
  CHKMEMQ;

  return 0;
}

Here is the call graph for this function:

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 NMDStringAppend ( char  s1,
NMD_string str1,
char  s2,
NMD_string  str2,
char  s3 
)

A version of NMDStringConcat() that appends to string 1, rather than creating a new string.

Definition at line 121 of file nmdutil.c.

References CHECKHASNMDCOOKIE, NMDStringConcat(), and NMDStringDestroy().

Referenced by NMDObjectDumpToMySQL().

{
  NMD_string nnew; NMDErrorCode ierr;
  CHECKHASNMDCOOKIE(*str1);
  CHECKHASNMDCOOKIE(str2);
  ierr = NMDStringConcat(s1,*str1,s2,str2,s3,&nnew); NMD_ERR_RETURN(ierr);
  ierr = NMDStringDestroy(*str1); NMD_ERR_RETURN(ierr);
  *str1 = nnew;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDStringConcat ( char  s1,
NMD_string  str1,
char  s2,
NMD_string  str2,
char  s3,
NMD_string r_str 
)

Concatenate string objects, with delimiter characters before, after, in between. All delimiters, and the second string, can be null.

Definition at line 74 of file nmdutil.c.

References CHECKHASNMDCOOKIE, NMD_string_::n, NMDStringCreateOfSize(), and NMD_string_::t.

Referenced by NMDObjectDumpToMySQL(), and NMDStringAppend().

{
  NMD_string str; NMDErrorCode ierr; int l;
  CHECKHASNMDCOOKIE(str1);

  l = str1->n + ( str2 ? str2->n : 0 ) + (s1!=0) + (s2!=0) + (s3!=0);
  ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr);

  l = 0;
  if (s1) {
    if (l+1>str->n) NMD_ERR_REPORT("string overflow");
    memcpy(str->t+l,&s1,1);
  }

  l = strlen(str->t);
  if (l+str1->n>str->n) NMD_ERR_REPORT("string overflow");
  memcpy(str->t+l,str1->t,str1->n);

  if (s2) {
    CHECKHASNMDCOOKIE(str2);
    l = strlen(str->t);
    if (l+1>str->n) NMD_ERR_REPORT("string overflow");
    memcpy(str->t+l,&s2,1);
  }

  if (str2) {
    l = strlen(str->t);
    if (l+str2->n>str->n) NMD_ERR_REPORT("string overflow");
    memcpy(str->t+l,str2->t,str2->n);
  }

  if (s3) {
    l = strlen(str->t);
    if (l+1>str->n) NMD_ERR_REPORT("string overflow");
    memcpy(str->t+l,&s3,1);
  }

  *r_str = str;
  return 0;
}

Here is the call graph for this function:

NMDErrorCode NMDStringCreate ( const char *  txt,
NMD_string r_str 
)

Create a string object around a C string; the C string is copied, so it can be freed by the calling environment.

Definition at line 36 of file nmdutil.c.

References NMDStringCreateOfSize(), and NMD_string_::t.

Referenced by NMDObjectDumpToMySQL().

{
  NMD_string str; NMDErrorCode ierr; int l;
  l = strlen(txt);
  ierr = NMDStringCreateOfSize(l,&str); NMD_ERR_RETURN(ierr);
  if (l) memcpy(str->t,txt,l);
  *r_str = str;
  return 0;
}

Here is the call graph for this function:

Destroy a string object, and free the stored string.

Definition at line 49 of file nmdutil.c.

References CHECKHASNMDCOOKIE, NMD_FREE, and NMD_string_::t.

Referenced by NMDObjectDumpToMySQL(), and NMDStringAppend().

{
  CHECKHASNMDCOOKIE(str);
  NMD_FREE(str->t); 
  NMD_FREE(str);
  return 0;
}
NMDErrorCode NMDStringGetString ( NMD_string  str,
const char **  t 
)

Return a pointer to the string in a string object

Definition at line 60 of file nmdutil.c.

References CHECKHASNMDCOOKIE, and NMD_string_::t.

Referenced by NMDObjectDumpToMySQL().

{
  CHECKHASNMDCOOKIE(str);
  *t = str->t;
  return 0;
}
NMDErrorCode NMDUnsetValue ( NMD_metadata  ,
const char *  ,
const char *   
)

Definition at line 464 of file nmd.c.

References CHECKHASNMDCOOKIE, CHKMEMQ, NMDCategoryTryGetComponent(), NMDComponentUnsetValue(), and NMDObjectTryGetCategory().

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

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

  return 0;
}

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

Definition at line 84 of file nmd.c.