cds_print.c cds3.h cds_private.h cds_print.c stdarg.h cds_private.h stdlib.h limits.h sys/types.h string.h cds3.h time.h messenger.h stdio.h int int _cds_print_att_array (FILE *fp, CDSAtt *att) _cds_print_att_array FILE * fp CDSAtt * att int int _cds_print_att_string (FILE *fp, CDSAtt *att) _cds_print_att_string FILE * fp CDSAtt * att int int _cds_print_data_array (FILE *fp, int line_length, CDSDataType type, size_t start, size_t count, CDSData data) _cds_print_data_array FILE * fp int line_length CDSDataType type size_t start size_t count CDSData data int int _cds_print_data_string (FILE *fp, size_t start, size_t count, CDSData data) _cds_print_data_string FILE * fp size_t start size_t count CDSData data int int cds_print (FILE *fp, CDSGroup *group, int flags) cds_print FILE * fp CDSGroup * group int flags Print CDS. By default (flags = 0) this function will print all dimensions, attributes, variables, groups, and data in the specified group.Control Flags: CDS_SKIP_GROUP_ATTS = do not print group attributesCDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_DATA = do not print variable dataCDS_SKIP_SUBGROUPS = do not print subgroups fp - pointer to the open file to print to group - pointer to the group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_att (FILE *fp, const char *indent, int min_width, CDSAtt *att) cds_print_att FILE * fp const char * indent int min_width CDSAtt * att Print a CDS Attribute. fp - pointer to the open file to print to indent - line indent string min_width - the minimum width used to print the attribute name att - pointer to the attribute number of bytes printednegative value if an error occurred int int cds_print_atts (FILE *fp, const char *indent, void *parent) cds_print_atts FILE * fp const char * indent void * parent Print CDS Attributes. fp - pointer to the open file to print to indent - line indent string parent - pointer to the parent group or variable number of bytes printednegative value if an error occurred int int cds_print_dim (FILE *fp, const char *indent, int min_width, CDSDim *dim) cds_print_dim FILE * fp const char * indent int min_width CDSDim * dim Print a CDS Dimension. fp - pointer to the open file to print to indent - line indent string min_width - the minimum width used to print the dimension name dim - pointer to the dimension number of bytes printednegative value if an error occurred int int cds_print_dims (FILE *fp, const char *indent, CDSGroup *group) cds_print_dims FILE * fp const char * indent CDSGroup * group Print CDS Dimensions. fp - pointer to the open file to print to indent - line indent string group - pointer to the group number of bytes printednegative value if an output error occurred int int cds_print_var (FILE *fp, const char *indent, CDSVar *var, int flags) cds_print_var FILE * fp const char * indent CDSVar * var int flags Print a CDS Variable. By default (flags = 0) all variable attributes will also be printed.Control Flags: CDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_DATA = do not print variable data fp - pointer to the open file to print to indent - line indent string var - pointer to the variable flags - control flags number of bytes printednegative value if an error occurred int int cds_print_vars (FILE *fp, const char *indent, CDSGroup *group, int flags) cds_print_vars FILE * fp const char * indent CDSGroup * group int flags Print CDS Variables. By default (flags = 0) all variable attributes will also be printed.Control Flags: CDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_DATA = do not print variable data fp - pointer to the open file to print to indent - line indent string group - pointer to the group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_var_data (FILE *fp, const char *indent, const char *label, CDSVar *var) cds_print_var_data FILE * fp const char * indent const char * label CDSVar * var Print CDS Variable Data. fp - pointer to the open file to print to indent - line indent string label - label to print before the = sign, or NULL to only print the data values var - pointer to the variable number of bytes printednegative value if an error occurred int int cds_print_data (FILE *fp, const char *indent, CDSGroup *group) cds_print_data FILE * fp const char * indent CDSGroup * group Print CDS Data. This function will print the data for all the variables in the specified group. fp - pointer to the open file to print to indent - line indent string group - pointer to the group number of bytes printednegative value if an error occurred int int cds_print_group (FILE *fp, const char *indent, CDSGroup *group, int flags) cds_print_group FILE * fp const char * indent CDSGroup * group int flags Print CDS Group. By default (flags = 0) this function will print all dimensions, attributes, variables, groups, and data in the specified group.Control Flags: CDS_SKIP_DIMS = do not print dimensionsCDS_SKIP_GROUP_ATTS = do not print group attributesCDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_VARS = do not print variablesCDS_SKIP_DATA = do not print variable dataCDS_SKIP_SUBGROUPS = do not traverse subgroups CDS_PRINT_VARGROUPS = print variable groups fp - pointer to the open file to print to indent - line indent string group - pointer to the group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_groups (FILE *fp, const char *indent, CDSGroup *group, int flags) cds_print_groups FILE * fp const char * indent CDSGroup * group int flags Print CDS Groups. This function will print all supgroups under the specified group.By default (flags = 0) this function will print all dimensions, attributes, variables, groups, and data in the subgroups.Control Flags: CDS_SKIP_DIMS = do not print dimensionsCDS_SKIP_GROUP_ATTS = do not print group attributesCDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_VARS = do not print variablesCDS_SKIP_DATA = do not print variable dataCDS_SKIP_SUBGROUPS = do not traverse subgroups CDS_PRINT_VARGROUPS = print variable groups fp - pointer to the open file to print to indent - line indent string group - pointer to the group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_vararray (FILE *fp, const char *indent, CDSVarArray *vararray, int flags) cds_print_vararray FILE * fp const char * indent CDSVarArray * vararray int flags Print CDS Variable Array. By default (flags = 0) this function will print all variables, variable attributes and data in the specified variable array.Control Flags: CDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_VARS = do not print variablesCDS_SKIP_DATA = do not print variable data fp - pointer to the open file to print to indent - line indent string vararray - pointer to the variable group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_vargroup (FILE *fp, const char *indent, CDSVarGroup *vargroup, int flags) cds_print_vargroup FILE * fp const char * indent CDSVarGroup * vargroup int flags Print CDS Variable Group. By default (flags = 0) this function will print all variables, variable attributes and data in the specified variable group.Control Flags: CDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_VARS = do not print variablesCDS_SKIP_DATA = do not print variable data fp - pointer to the open file to print to indent - line indent string vargroup - pointer to the variable group flags - control flags number of bytes printednegative value if an error occurred int int cds_print_vargroups (FILE *fp, const char *indent, CDSGroup *group, int flags) cds_print_vargroups FILE * fp const char * indent CDSGroup * group int flags Print CDS Variable Groups. By default (flags = 0) this function will print all variables, variable attributes and data for the variable groups in the specified CDS group.Control Flags: CDS_SKIP_VAR_ATTS = do not print variable attributesCDS_SKIP_VARS = do not print variablesCDS_SKIP_DATA = do not print variable data fp - pointer to the open file to print to indent - line indent string group - pointer to the variable group flags - control flags number of bytes printednegative value if an error occurred CDS Print Functions. /******************************************************************************* * *COPYRIGHT(C)2010BattelleMemorialInstitute.AllRightsReserved. * ******************************************************************************** * *Author: *name:BrianErmold *phone:(509)375-2277 *email:brian.ermold@pnl.gov * ******************************************************************************** * *REPOSITORYINFORMATION: *$Revision:63472$ *$Author:ermold$ *$Date:2015-08-2620:39:27+0000(Wed,26Aug2015)$ * ******************************************************************************** * *NOTE:DOXYGENisusedtogeneratedocumentationforthisfile. * *******************************************************************************/ /**@filecds_print.c *CDSPrintFunctions. */ #include"cds3.h" #include"cds_private.h" /******************************************************************************* *PrivateFunctions */ /**@privatesection*/ int_cds_print_att_array(FILE*fp,CDSAtt*att) { intnbytes; inttbytes; size_ti; nbytes=fprintf(fp,"["); if(nbytes<0)return(nbytes); tbytes=nbytes; if(att->length>0){ for(i=0;i<att->length;i++){ switch(att->type){ caseCDS_BYTE: nbytes=fprintf(fp,"%d",att->value.bp[i]); break; caseCDS_SHORT: nbytes=fprintf(fp,"%d",att->value.sp[i]); break; caseCDS_INT: nbytes=fprintf(fp,"%d",att->value.ip[i]); break; caseCDS_FLOAT: nbytes=fprintf(fp,"%.7g",att->value.fp[i]); break; caseCDS_DOUBLE: nbytes=fprintf(fp,"%.15g",att->value.dp[i]); break; default: break; } if(nbytes<0)return(nbytes); tbytes+=nbytes; if(i<att->length-1){ nbytes=fprintf(fp,","); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } } nbytes=fprintf(fp,"]"); if(nbytes<0)return(nbytes); tbytes+=nbytes; return(tbytes); } int_cds_print_att_string(FILE*fp,CDSAtt*att) { intnbytes; inttbytes; intlength; inti; char*cp; charuc; length=att->length; nbytes=fprintf(fp,"\""); if(nbytes<0)return(nbytes); tbytes=nbytes; if(length>0){ /*Adjustthelengthsotrailingnullsdon'tgetprinted*/ cp=att->value.cp+length-1; while(length&&*cp=='\0'){ cp--; length--; } for(i=0;i<length;i++){ switch(uc=att->value.cp[i]&0377){ case'\b':nbytes=fprintf(fp,"\\b");break; case'\f':nbytes=fprintf(fp,"\\f");break; case'\r':nbytes=fprintf(fp,"\\r");break; case'\v':nbytes=fprintf(fp,"\\v");break; default:nbytes=fprintf(fp,"%c",uc);break; } if(nbytes<0)return(nbytes); tbytes+=nbytes; } } nbytes=fprintf(fp,"\""); if(nbytes<0)return(nbytes); tbytes+=nbytes; return(tbytes); } int_cds_print_data_array( FILE*fp, intline_length, CDSDataTypetype, size_tstart, size_tcount, CDSDatadata) { intnbytes; inttbytes; size_tend; intstr_length; charstr_value[32]; size_ti; tbytes=0; end=start+count; if(!data.vp){ return(0); } for(i=start;i<end;i++){ switch(type){ caseCDS_BYTE: str_length=sprintf(str_value,"%d",data.bp[i]); break; caseCDS_SHORT: str_length=sprintf(str_value,"%d",data.sp[i]); break; caseCDS_INT: str_length=sprintf(str_value,"%d",data.ip[i]); break; caseCDS_FLOAT: str_length=sprintf(str_value,"%.7g",data.fp[i]); break; caseCDS_DOUBLE: str_length=sprintf(str_value,"%.15g",data.dp[i]); break; default: str_length=sprintf(str_value,"NaT"); break; } if(i==start){ nbytes=fprintf(fp,"%s",str_value); line_length+=str_length; } elseif((line_length+str_length+4)>80){ nbytes=fprintf(fp,",\n%s",str_value); line_length=str_length+4; } else{ nbytes=fprintf(fp,",%s",str_value); line_length+=str_length+2; } if(nbytes<0)return(nbytes); tbytes+=nbytes; } return(tbytes); } int_cds_print_data_string( FILE*fp, size_tstart, size_tcount, CDSDatadata) { intnbytes; inttbytes; size_tend; charuc; size_ti; nbytes=fprintf(fp,"\""); if(nbytes<0)return(nbytes); tbytes=nbytes; end=start+count; for(i=start;i<end;i++){ switch(uc=data.cp[i]&0377){ case'\0':nbytes=fprintf(fp,"\\0");break; case'\b':nbytes=fprintf(fp,"\\b");break; case'\f':nbytes=fprintf(fp,"\\f");break; case'\n':nbytes=fprintf(fp,"\\n");break; case'\r':nbytes=fprintf(fp,"\\r");break; case'\t':nbytes=fprintf(fp,"\\t");break; case'\v':nbytes=fprintf(fp,"\\v");break; case'\"':nbytes=fprintf(fp,"\\\"");break; default:nbytes=fprintf(fp,"%c",uc);break; } if(nbytes<0)return(nbytes); tbytes+=nbytes; } nbytes=fprintf(fp,"\""); if(nbytes<0)return(nbytes); tbytes+=nbytes; return(tbytes); } /******************************************************************************* *PublicFunctions */ /**@publicsection*/ /** *PrintCDS. * *Bydefault(flags=0)thisfunctionwillprintalldimensions, *attributes,variables,groups,anddatainthespecifiedgroup. * *ControlFlags: * *-CDS_SKIP_GROUP_ATTS=donotprintgroupattributes *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_DATA=donotprintvariabledata *-CDS_SKIP_SUBGROUPS=donotprintsubgroups * *@paramfp-pointertotheopenfiletoprintto *@paramgroup-pointertothegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print( FILE*fp, CDSGroup*group, intflags) { return(cds_print_group(fp,"",group,flags)); } /** *PrintaCDSAttribute. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@parammin_width-theminimumwidthusedtoprinttheattributename *@paramatt-pointertotheattribute * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_att( FILE*fp, constchar*indent, intmin_width, CDSAtt*att) { constchar*type_name=cds_data_type_name(att->type); charformat[64]; intnbytes; inttbytes; sprintf(format,"%%s%%-%ds=",min_width); nbytes=fprintf(fp,format,indent,att->name); if(nbytes<0)return(nbytes); tbytes=nbytes; if(att->type==CDS_CHAR){ nbytes=_cds_print_att_string(fp,att); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=fprintf(fp,"\n"); } else{ nbytes=_cds_print_att_array(fp,att); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=fprintf(fp,":%s\n",type_name); } if(nbytes<0)return(nbytes); tbytes+=nbytes; return(tbytes); } /** *PrintCDSAttributes. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramparent-pointertotheparentgrouporvariable * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_atts( FILE*fp, constchar*indent, void*parent) { CDSObject*parent_object=(CDSObject*)parent; CDSGroup*group; CDSVar*var; CDSAtt**atts; intnatts; intmin_width; intlength; intai; intnbytes; inttbytes; /*Makesuretheparentisagrouporvariable*/ if(parent_object->obj_type==CDS_GROUP){ group=(CDSGroup*)parent; natts=group->natts; atts=group->atts; } elseif(parent_object->obj_type==CDS_VAR){ var=(CDSVar*)parent_object; natts=var->natts; atts=var->atts; } else{ return(0); } tbytes=0; if(natts){ min_width=0; for(ai=0;ai<natts;ai++){ length=strlen(atts[ai]->name); if(min_width<length){ min_width=length; } } for(ai=0;ai<natts;ai++){ nbytes=cds_print_att(fp,indent,min_width,atts[ai]); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } return(tbytes); } /** *PrintaCDSDimension. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@parammin_width-theminimumwidthusedtoprintthedimensionname *@paramdim-pointertothedimension * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_dim( FILE*fp, constchar*indent, intmin_width, CDSDim*dim) { charformat[64]; inttbytes; if(dim->is_unlimited){ sprintf(format,"%%s%%-%ds=UNLIMITED(%%ldcurrently)\n",min_width); } else{ sprintf(format,"%%s%%-%ds=%%ld\n",min_width); } tbytes=fprintf(fp,format,indent,dim->name,(long)dim->length); return(tbytes); } /** *PrintCDSDimensions. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothegroup * *@return *-numberofbytesprinted *-negativevalueifanoutputerroroccurred */ intcds_print_dims( FILE*fp, constchar*indent, CDSGroup*group) { intmin_width; intlength; intdi; intnbytes; inttbytes; tbytes=0; if(group->ndims){ min_width=0; for(di=0;di<group->ndims;di++){ length=strlen(group->dims[di]->name); if(min_width<length){ min_width=length; } } for(di=0;di<group->ndims;di++){ nbytes=cds_print_dim(fp,indent,min_width,group->dims[di]); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } return(tbytes); } /** *PrintaCDSVariable. * *Bydefault(flags=0)allvariableattributeswillalsobeprinted. * *ControlFlags: * *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_DATA=donotprintvariabledata * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramvar-pointertothevariable *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_var( FILE*fp, constchar*indent, CDSVar*var, intflags) { constchar*type_name=cds_data_type_name(var->type); CDSDim*dim; char*indent4; intdi; intnbytes; inttbytes; /*PrintVariableNameandDimensions*/ nbytes=fprintf(fp,"%s%s(",indent,var->name); if(nbytes<0)return(nbytes); tbytes=nbytes; for(di=0;di<var->ndims;di++){ dim=var->dims[di]; if(di){nbytes=fprintf(fp,",%s",dim->name);} else{nbytes=fprintf(fp,"%s",dim->name);} if(nbytes<0)return(nbytes); tbytes+=nbytes; } nbytes=fprintf(fp,"):%s\n",type_name); if(nbytes<0)return(nbytes); tbytes+=nbytes; /*PrintVariableAttributes*/ if(!(flags&CDS_SKIP_VAR_ATTS)){ if(var->natts){ indent4=msngr_create_string("%s",indent); if(!indent4){ return(-1); } nbytes=cds_print_atts(fp,indent4,var); if(nbytes<0){ free(indent4); return(nbytes); } tbytes+=nbytes; free(indent4); } } /*PrintVariableData*/ if(!(flags&CDS_SKIP_DATA)){ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=cds_print_var_data(fp,indent,"data",var); if(nbytes<0)return(nbytes); tbytes+=nbytes; } return(tbytes); } /** *PrintCDSVariables. * *Bydefault(flags=0)allvariableattributeswillalsobeprinted. * *ControlFlags: * *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_DATA=donotprintvariabledata * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_vars( FILE*fp, constchar*indent, CDSGroup*group, intflags) { intvi; intnbytes; inttbytes; tbytes=0; if(group->nvars){ for(vi=0;vi<group->nvars;vi++){ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=cds_print_var(fp,indent,group->vars[vi],flags); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } return(tbytes); } /** *PrintCDSVariableData. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramlabel-labeltoprintbeforethe=sign, *orNULLtoonlyprintthedatavalues *@paramvar-pointertothevariable * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_var_data( FILE*fp, constchar*indent, constchar*label, CDSVar*var) { size_tsample_size; intnbytes; inttbytes; size_tsi; tbytes=0; if(label){ nbytes=fprintf(fp,"%s%s=",indent,label); if(nbytes<0)return(nbytes); tbytes+=nbytes; if(!var->sample_count){ nbytes=fprintf(fp,"NULL\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; return(tbytes); } } elseif(!var->sample_count){ return(0); } else{ nbytes=fprintf(fp,"%s",indent); if(nbytes<0)return(nbytes); tbytes+=nbytes; } sample_size=cds_var_sample_size(var); if(sample_size==1){ if(var->type==CDS_CHAR){ nbytes=_cds_print_data_string( fp,0,var->sample_count,var->data); } else{ nbytes=_cds_print_data_array( fp,nbytes,var->type,0,var->sample_count,var->data); } if(nbytes<0)return(nbytes); tbytes+=nbytes; } else{ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; for(si=0;si<var->sample_count;si++){ if(var->type==CDS_CHAR){ nbytes=_cds_print_data_string( fp,si*sample_size,sample_size,var->data); } else{ nbytes=_cds_print_data_array( fp,8,var->type,si*sample_size,sample_size,var->data); } if(nbytes<0)return(nbytes); tbytes+=nbytes; if(si<var->sample_count-1){ nbytes=fprintf(fp,",\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } } nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes=nbytes; return(tbytes); } /** *PrintCDSData. * *Thisfunctionwillprintthedataforallthevariables *inthespecifiedgroup. * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothegroup * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_data( FILE*fp, constchar*indent, CDSGroup*group) { CDSVar*var; intnbytes; inttbytes; intvi; tbytes=0; if(group->nvars){ for(vi=0;vi<group->nvars;vi++){ var=group->vars[vi]; nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=cds_print_var_data(fp,indent,var->name,var); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } return(tbytes); } /** *PrintCDSGroup. * *Bydefault(flags=0)thisfunctionwillprintalldimensions, *attributes,variables,groups,anddatainthespecifiedgroup. * *ControlFlags: * *-CDS_SKIP_DIMS=donotprintdimensions *-CDS_SKIP_GROUP_ATTS=donotprintgroupattributes *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_VARS=donotprintvariables *-CDS_SKIP_DATA=donotprintvariabledata *-CDS_SKIP_SUBGROUPS=donottraversesubgroups * *-CDS_PRINT_VARGROUPS=printvariablegroups * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_group( FILE*fp, constchar*indent, CDSGroup*group, intflags) { char*indent8; intnbytes; inttbytes; tbytes=0; /*Createtheindentstring*/ indent8=msngr_create_string("%s",indent); if(!indent8){ return(-1); } /*Printgrouppath*/ nbytes=fprintf(fp,"\n%sGroup:%s\n", indent,cds_get_object_path(group)); if(nbytes<0){ free(indent8); return(nbytes); } tbytes=nbytes; /*PrintDimensions*/ if(!(flags&CDS_SKIP_DIMS)&&group->ndims){ nbytes=fprintf(fp,"\n%sDimensions:\n\n",indent); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; nbytes=cds_print_dims(fp,indent8,group); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } /*PrintAttributes*/ if(!(flags&CDS_SKIP_GROUP_ATTS)&&group->natts){ nbytes=fprintf(fp,"\n%sAttributes:\n\n",indent); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; nbytes=cds_print_atts(fp,indent8,group); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } /*PrintVariables*/ if(!(flags&CDS_SKIP_VARS)&&group->nvars){ nbytes=fprintf(fp,"\n%sVariables:\n",indent); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; nbytes=cds_print_vars(fp,indent8,group,flags|CDS_SKIP_DATA); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } /*PrintVariableGroups*/ if((flags&CDS_PRINT_VARGROUPS)&&group->nvargroups){ nbytes=fprintf(fp,"\n%sVariableGroups:\n",indent); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; nbytes=cds_print_vargroups(fp,indent8,group,CDS_SKIP_VARS); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } /*PrintData*/ if(!(flags&CDS_SKIP_DATA)&&group->nvars){ nbytes=fprintf(fp,"\n%sData:\n",indent); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; nbytes=cds_print_data(fp,indent8,group); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } /*PrintGroup*/ if(!(flags&CDS_SKIP_SUBGROUPS)){ nbytes=cds_print_groups(fp,indent,group,flags); if(nbytes<0){ free(indent8); return(nbytes); } tbytes+=nbytes; } free(indent8); return(tbytes); } /** *PrintCDSGroups. * *Thisfunctionwillprintallsupgroupsunderthespecifiedgroup. * *Bydefault(flags=0)thisfunctionwillprintalldimensions, *attributes,variables,groups,anddatainthesubgroups. * *ControlFlags: * *-CDS_SKIP_DIMS=donotprintdimensions *-CDS_SKIP_GROUP_ATTS=donotprintgroupattributes *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_VARS=donotprintvariables *-CDS_SKIP_DATA=donotprintvariabledata *-CDS_SKIP_SUBGROUPS=donottraversesubgroups * *-CDS_PRINT_VARGROUPS=printvariablegroups * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_groups( FILE*fp, constchar*indent, CDSGroup*group, intflags) { intnbytes; inttbytes; inti; tbytes=0; for(i=0;i<group->ngroups;i++){ nbytes=cds_print_group( fp,indent,group->groups[i],flags); if(nbytes<0){ return(nbytes); } tbytes+=nbytes; } return(tbytes); } /** *PrintCDSVariableArray. * *Bydefault(flags=0)thisfunctionwillprintallvariables, *variableattributesanddatainthespecifiedvariablearray. * *ControlFlags: * *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_VARS=donotprintvariables *-CDS_SKIP_DATA=donotprintvariabledata * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramvararray-pointertothevariablegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_vararray( FILE*fp, constchar*indent, CDSVarArray*vararray, intflags) { CDSVar*var; char*indent4; intnbytes; inttbytes; intvi; tbytes=0; if(!vararray->nvars){ nbytes=fprintf(fp,"\n%s%s=NULL\n",indent,vararray->name); return(nbytes); } if((flags&CDS_SKIP_VARS)&&vararray->nvars){ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; } /*Createtheindentstring*/ indent4=msngr_create_string("%s",indent); if(!indent4){ return(-1); } /*Printvariables*/ for(vi=0;vi<vararray->nvars;vi++){ var=vararray->vars[vi]; if(!(flags&CDS_SKIP_VARS)){ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; } if(!var){ nbytes=fprintf(fp,"%s%s[%d]:NULL\n", indent,vararray->name,vi); if(nbytes<0)return(nbytes); tbytes+=nbytes; } else{ nbytes=fprintf(fp,"%s%s[%d]:%s\n", indent,vararray->name,vi,cds_get_object_path(var)); if(nbytes<0)return(nbytes); tbytes+=nbytes; if(!(flags&CDS_SKIP_VARS)){ nbytes=fprintf(fp,"\n"); if(nbytes<0)return(nbytes); tbytes+=nbytes; nbytes=cds_print_var(fp,indent4,var,flags); if(nbytes<0)return(nbytes); tbytes+=nbytes; } } } free(indent4); return(tbytes); } /** *PrintCDSVariableGroup. * *Bydefault(flags=0)thisfunctionwillprintallvariables, *variableattributesanddatainthespecifiedvariablegroup. * *ControlFlags: * *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_VARS=donotprintvariables *-CDS_SKIP_DATA=donotprintvariabledata * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramvargroup-pointertothevariablegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_vargroup( FILE*fp, constchar*indent, CDSVarGroup*vargroup, intflags) { char*indent4; intnbytes; inttbytes; intai; tbytes=0; /*Printvargrouppath*/ nbytes=fprintf(fp,"\n%sVarGroup:%s\n", indent,cds_get_object_path(vargroup)); if(nbytes<0){ return(nbytes); } tbytes=nbytes; /*Createtheindentstring*/ indent4=msngr_create_string("%s",indent); if(!indent4){ return(-1); } /*PrintVariableArrays*/ for(ai=0;ai<vargroup->narrays;ai++){ nbytes=cds_print_vararray(fp,indent4,vargroup->arrays[ai],flags); if(nbytes<0){ free(indent4); return(nbytes); } tbytes+=nbytes; } free(indent4); return(tbytes); } /** *PrintCDSVariableGroups. * *Bydefault(flags=0)thisfunctionwillprintallvariables, *variableattributesanddataforthevariablegroupsinthe *specifiedCDSgroup. * *ControlFlags: * *-CDS_SKIP_VAR_ATTS=donotprintvariableattributes *-CDS_SKIP_VARS=donotprintvariables *-CDS_SKIP_DATA=donotprintvariabledata * *@paramfp-pointertotheopenfiletoprintto *@paramindent-lineindentstring *@paramgroup-pointertothevariablegroup *@paramflags-controlflags * *@return *-numberofbytesprinted *-negativevalueifanerroroccurred */ intcds_print_vargroups( FILE*fp, constchar*indent, CDSGroup*group, intflags) { intnbytes; inttbytes; intgi; tbytes=0; /*PrintVariableGroups*/ for(gi=0;gi<group->nvargroups;gi++){ nbytes=cds_print_vargroup(fp,indent,group->vargroups[gi],flags); if(nbytes<0){ return(nbytes); } tbytes+=nbytes; } return(tbytes); }