typedef struct {

       //  Private
       int structType;

       //  Optional input
       //  For normal catalog, statusWanted = 0, and typeWanted = 0.
       int statusWanted;
       int typeWantedStart;
       int typeWantedEnd;

       //  Search according to record last write time (e.g., records written to
       //  since a previous time (using file header write time)
       //  Times are system times, in mills
       //  lastWriteTimeSearch == 0 for ignore (default)
       //  lastWriteTimeSearchFlag:
       //           -2:          time <  lastWriteTimeSearch
       //           -1:          time <= lastWriteTimeSearch
       //           0:          time == lastWriteTimeSearch
       //           1:          time >= lastWriteTimeSearch
       //           2:          time >  lastWriteTimeSearch
       long long lastWriteTimeSearch;
       int lastWriteTimeSearchFlag;

       //  Output
       //  An array of the pathnames in the DSS file
       char **pathnameList;
       int numberPathnames;  //  number of valid pathnames in list
       int boolSorted;
       int boolIsCollection;

       //  Attributes are descriptors for records, usually used for searching in a list,
       //  but are not used for unique identity.
       //  "::" separates key from attribute, ";;" separates attribute sets
       //  For example
       //  pathnameList[43] = /Tulare/Delano/Flow/01Jan1980/1Day/Obs/"
       //  attribues[43] = "County::Kern;;State::CA;;Region::Southern"
       //  pathnameList[78] = /American/Fair Oaks Local/Flow/01Jan2200/1Hour/ReReg/"
       //  attribues[78] = "Type::Subbasin;;Order::142"
       int boolHasAttribues;
       char **attributes;

       //  If boolIncludeDates == 1 on input, then startDates and endDates
       //  will be int arrays of the Julian first and last date for each
       //  record (pathname)
       int boolIncludeDates;
       int *startDates;
       int *endDates;

       //  Always returns these (right there)
       int *recordType;
       long long *pathnameHash;
       long long *lastWriteTimeRecord;
       long long lastWriteTimeFile;

       //  CRC values - Resource intensive!  Only use if you really needed
       unsigned int *crcValues;
       int boolGetCRCvalues;   //  Set to 1 to have CRC values computed

       //  Private
       int listSize;  // size allocated
       long long *sortAddresses;  //  Used for sorting
       char *pathWithWildChars;  //  Only for info
       char allocated[zSTRUCT_length];

} zStructCatalog;

#include <stdio.h>
#include "heclib.h"

//  A short example of getting a catalog or list of pathnames in a DSS file

int ExampleCatalog1()
{
         long long ifltab[250];
         zStructCatalog *catStruct;
         int status;
         int i, number;

         //  Open the DSS file
         status = zopen(ifltab, "C:/temp/Sample7.dss");
         if (status != STATUS_OKAY) return status;

         //  Create a catalog struct
         catStruct = zstructCatalogNew();
         // int zcatalog(long long *ifltab, const char *pathWithWild,
         //        zStructCatalog *catStruct, int sortCollectionFlag);
         status = zcatalog(ifltab, (const char *)0, catStruct, 1);
         if (status < 0) {
                 printf("Error during catalog.  Error code %d\n", status);
                 return status;
         }

         number = 20;
         if (catStruct->numberPathnames < 20) number = catStruct→numberPathnames;
         printf("First %d pathnames are:\n", number);
         for (i = 0; i < number; i++) {
                 printf("%s\n", catStruct->pathnameList[i]);

         }

         zstructFree(catStruct);
         zclose(ifltab);
         printf("\nCompleted catalog example\n");
         return 0;
}

#include <stdio.h>
#include "heclib.h"

//  A short example to demonstrate catalog functions

int ExampleCatalog2()
{
         long long ifltab[250];
         zStructCatalog *catStruct;
         char *dssFilename;
         int status;
         int version;
         int i, number;

         //  Open the DSS file. It must exist for this example
         dssFilename = mallocAndCopy("C:/temp/Sample7.dss");
         version = zgetFileVersion(dssFilename);
         if (version != 7) {
                 printf("Error, %s must exist and be a version 7 file\n", dssFilename);
                 return -1;
         }
         status = zopen(ifltab, dssFilename);
         if (status != STATUS_OKAY) return status;

         //  Create a catalog struct
         catStruct = zstructCatalogNew();
         //  Generic full sorted catalog
         status = zcatalog(ifltab, (const char *)0, catStruct, 1);
         if (status < 0) {
                 printf("Error during catalog.  Error code %d\n", status);
                 return status;
         }
         else if (status == 0) {
                 printf("There are no records in DSS file %s\n", dssFilename);
                 return status;
         }
         else {
                 printf("There are %d records in DSS file %s\n", status, dssFilename);
         }

         //  Now get all pathnames with an F part of "obs" and a C part that contains "flow"
         zstructFree(catStruct);
         catStruct = zstructCatalogNew();
         status = zcatalog(ifltab, "/*/*/*flow*/*/*/obs/", catStruct, 1);
         if (status < 0) {
                 printf("Error during catalog.  Error code %d\n", status);
                 return status;
         }
         else if (status == 0) {
                 printf("There are no records in DSS file %s with wild path /*/*/*flow*/*/*/obs/\n", dssFilename);
                 return status;
         }
         else {
                 printf("There are %d records in DSS file %s with wild path /*/*/*flow*/*/*/obs/\n", status, dssFilename);
         }

         number = 20;
         if (catStruct->numberPathnames < 20) number = catStruct→numberPathnames;
         printf("First %d wild character pathnames are:\n", number);
         for (i = 0; i < number; i++) {
                 printf("%s\n", catStruct→pathnameList[i]);
         }

//  Now write all pathnames to a text file
         status = zcatalogFile(ifltab, "C:/temp/Sample7.txt", 0, (const char *)0);
         if (status < 0) {
                 printf("Error during catalog.  Error code %d\n", status);
                 return status;
         }
         else if (status == 0) {
                 printf("There are no records in DSS file %s\n", dssFilename);
                 return status;
         }
         else {
                 printf("There were %d pathnames written to file C:/temp/Sample7.txt\n", status);
         }

         zstructFree(catStruct);
         free(dssFilename);
         zclose(ifltab);
         printf("\nCompleted catalog example\n");
         return 0;
}

catStruct = zstructCatalogNew();
status = zwhatChangedSetStart(ifltab, catStruct, "/*/*/Flow*/*/*/*/", 1);
startTime = zgetLastWriteTimeFile(ifltab); 
// Do stuff here with wait loop
... 
lastWriteTime = zgetLastWriteTimeFile(ifltab);
if (lastWriteTime != startTime) {
       catStruct1 = zstructCatalogNew();
       numberIn = zwhatChangedCompare(ifltab, catStruct, catStruct1, "///Flow-In///*/", 1);
       if (numberIn > 0) {
              // Process those records
              . . .
       } 
       zstructFree(catStruct1);
       catStruct1 = zstructCatalogNew();
       numberOut = zwhatChangedCompare(ifltab, catStruct, catStruct1, "///Flow-Out///*/", 1);
       if (number > 0) {
              // Process those records
              . . .
       }
       zstructFree(catStruct1);
       if ((numberIn > 0) || (numberOut > 0)) {
              // Reset the dataset
              zstructFree(catStruct1);
              catStruct = zstructCatalogNew();
              status = zwhatChangedSetStart(ifltab, catStruct, "///Flow*///*/", 1);
       }
       startTime = zgetLastWriteTimeFile(ifltab); 
}

#include <stdio.h>
#include "heclib.h"

//  A short example to demonstrate the what changed functions

int ExampleCatalog3()
{
         long long ifltab[250];
         zStructCatalog *catStruct;
         zStructTimeSeries *tss;
         char *dssFilename;
         int status;
         int version;
         long long startTime;
         long long lastWriteTime;
         int count;
         int i, number;

         //  Open the DSS file. It must exist for this example
         dssFilename = mallocAndCopy("C:/temp/Sample7.dss");
         version = zgetFileVersion(dssFilename);
         if (version != 7) {
                 printf("Error, %s must exist and be a version 7 file\n", dssFilename);
                 return -1;
         }
         status = zopen(ifltab, dssFilename);
         if (status != STATUS_OKAY) return status;

         //  Set our start point
         status = zwhatChangedSetStart(ifltab, (zStructCatalog*)0, (const char*)0, 0);
         if (status != STATUS_OKAY) {
                 printf("Error during zwhatChangedSetStart.  Error code %d\n", status);
                 return status;
         }
         //  Get the starting file last write time
         startTime = zgetLastWriteTimeFile(ifltab);

         //  Loop, checking last write time, then waiting a second
         count = 0;
         //  Note - we are using 1 for demo; you wouldn't normally have a non-exit loop
         while (1) {
                 printf("waiting...\n");
                 _sleep(1000);
                 lastWriteTime = zgetLastWriteTimeFile(ifltab);
                 if (lastWriteTime != startTime) break
                 //  Pretend that another process is writing to the file
                 if (count == 5) {
                          tss = zstructTsNew("//SACRAMENTO/TEMP-MAX/01Jan1960/1Day/OBS/");
                          status = ztsRetrieve(ifltab, tss, 0, 1, 0);
                          if (status != STATUS_OKAY) return status;
                          //  Add one to all values, then store again.
                          for (i = 0; i < tss->numberValues; i++) {
                                  tss->floatValues[i] += (float)1.0;
                          }
                          status = ztsStore(ifltab, tss, 0);
                          if (status != STATUS_OKAY) return status;
                          zstructFree(tss);
                 }
                 count++;
         }

         //  What has changed since the start?
         catStruct = zstructCatalogNew();
         number = zwhatChanged(ifltab, catStruct);
         if (number < STATUS_OKAY) return number;
         printf("\nThe file has been written to and %d records have changed\n", number);
         printf("Those records are:\n");
         for (i = 0; i < catStruct->numberPathnames; i++) {
                 printf("%s\n", catStruct→pathnameList[i]);
         }

         zstructFree(catStruct);
         free(dssFilename);
         zclose(ifltab);
         printf("\nCompleted what changed example\n");
         return 0;
}

#include <stdio.h>
#include "heclib.h"

//  A similar example to ExampleCatalog3, but check for different types of data

int ExampleCatalog4()
{
         long long ifltab[250];
         zStructCatalog *catStruct1, *catStruct2, *catStruct;
         zStructTimeSeries *tss;
         char *dssFilename;
         int status;
         int version;
         long long startTime;
         long long lastWriteTime;
         int count;
         int i, number;

         //  Open the DSS file. It must exist for this example
         dssFilename = mallocAndCopy("C:/temp/Sample7.dss");
         version = zgetFileVersion(dssFilename);
         if (version != 7) {
                 printf("Error, %s must exist and be a version 7 file\n", dssFilename);
                 return -1;
         }
         status = zopen(ifltab, dssFilename);
         if (status != STATUS_OKAY) return status;

         //  For this example, we will be using different structs, which is more efficient
         //  both in speed and memory.  However, you can use just one if you want (e.g., a small file.)
         //  Set our start point for temperature.  Use CRC
         catStruct1 = zstructCatalogNew();
         status = zwhatChangedSetStart(ifltab, catStruct1, "/*/*/Temp*/*/*/*/", 1);
         if (status < STATUS_OKAY) {
                 printf("Error during zwhatChangedSetStart.  Error code %d\n", status);
                 return status;
         }

         //  Now the start point for precip. 
         catStruct2 = zstructCatalogNew();
         status = zwhatChangedSetStart(ifltab, catStruct2, "/*/*/Precip*/*/*/*/", 1);
         if (status < STATUS_OKAY) {
                 printf("Error during zwhatChangedSetStart.  Error code %d\n", status);
                 return status;
         }

         //  Get the starting file last write time
         startTime = zgetLastWriteTimeFile(ifltab);

         //  Loop, checking last write time, then waiting a second
         count = 0;
         while (count < 12) {
                 printf("waiting...\n");
                 _sleep(1000);
                 lastWriteTime = zgetLastWriteTimeFile(ifltab);
                 if (lastWriteTime != startTime) {
                          //  A lot of stuff could be changing in the file, but we are only interesed in two data types
                          //  We'll use the compare function to see if it is one of the ones we want
                          catStruct = zstructCatalogNew();
                          number = zwhatChangedCompare(ifltab, catStruct1, catStruct, "/*/*/Temp*/*/*/*/", 1);
                          if (number < STATUS_OKAY) return number;
                          if (number > 0) {
                                  printf("\nTemperature data has been written to and %d records have changed\n", number);
                                  printf("Those records are:\n");
                                  for (i = 0; i < catStruct->numberPathnames; i++) {
                                           printf("%s\n", catStruct→pathnameList[i]);
                                  }
                                  //  Since we've processed these records, reset the original struct
                                  zstructFree(catStruct1);
                                  catStruct1 = zstructCatalogNew();
                                  status = zwhatChangedSetStart(ifltab, catStruct1, "/*/*/Temp*/*/*/*/", 1);
                                  if (status < STATUS_OKAY) return status;
                          }
                          zstructFree(catStruct);
                          catStruct = zstructCatalogNew();
                          number = zwhatChangedCompare(ifltab, catStruct2, catStruct, "/*/*/Precip*/*/*/*/", 1);
                          if (number < STATUS_OKAY) return number;
                          if (number > 0) {
                                  printf("\nPrecipitation data has been written to and %d records have changed\n", number);
                                  printf("Those records are:\n");
                                  for (i = 0; i < catStruct->numberPathnames; i++) {
                                           printf("%s\n", catStruct→pathnameList[i]);
                                  }
                                  zstructFree(catStruct2);
                                  catStruct2 = zstructCatalogNew();
                                  status = zwhatChangedSetStart(ifltab, catStruct2, "/*/*/Precip*/*/*/*/", 1);
                                  if (status < STATUS_OKAY) return status;
                          }
                          zstructFree(catStruct);
                          //  Reset the start time
                          startTime = zgetLastWriteTimeFile(ifltab);
                 }

                 //  Pretend that another process is writing to the file
                 if (count == 4) {
                          tss = zstructTsNew("//SACRAMENTO/TEMP-MAX/01Jan1960/1Day/OBS/");
                          status = ztsRetrieve(ifltab, tss, 0, 1, 0);
                          if (status != STATUS_OKAY) return status;
                          //  Add one to all values, then store again.
                          for (i = 0; i < tss->numberValues; i++) {
                                  tss->floatValues[i] += (float)1.0;
                          }
                          status = ztsStore(ifltab, tss, 0);
                          if (status != STATUS_OKAY) return status;
                          zstructFree(tss);
                 }

                 if (count == 8) {
                          tss = zstructTsNew("//SACRAMENTO/PRECIP-INC/01Jan1980/1Day/OBS/");
                          status = ztsRetrieve(ifltab, tss, 0, 1, 0);
                          if (status != STATUS_OKAY) return status;
                          //  Add .05 to all values, then store again.
                          for (i = 0; i < tss->numberValues; i++) {
                                  tss->floatValues[i] += (float)0.05;
                          }
                          status = ztsStore(ifltab, tss, 0);
                          if (status != STATUS_OKAY) return status;
                          zstructFree(tss);
                 }
                 count++;
         }

         zstructFree(catStruct1);
         zstructFree(catStruct2);
         free(dssFilename);
         zclose(ifltab);
         printf("\nCompleted what changed example\n");
         return 0;
}