Collects data from multiple columns into new grouped columns based on specified criteria. More...

#include "mdb.h"
#include "SDDS.h"
#include "SDDSutils.h"
#include "scan.h"
#include <ctype.h>

Classes
struct	COLLECTION

struct	NEW_PARAMETER

Macros
#define	COLLECTION_SUFFIX 0x0001U

#define	COLLECTION_PREFIX 0x0002U

#define	COLLECTION_COLUMN 0x0004U

#define	COLLECTION_MATCH 0x0008U

#define	COLLECTION_EDIT 0x0010U

#define	COLLECTION_EXCLUDE 0x0020U

Enumerations
enum	option_type { CLO_COLLECT , CLO_PIPE , CLO_NOWARNINGS , CLO_MAJOR_ORDER , N_OPTIONS }

Functions
long	InitializeOutput (SDDS_DATASET SDDSout, char output, SDDS_DATASET SDDSin, COLLECTION collection, long collections, NEW_PARAMETER *newParameter, int newParameters, char *rootname, char *units, long warnings)

void	CollectAndWriteData (SDDS_DATASET SDDSout, COLLECTION collection, long collections, NEW_PARAMETER newParameter, int newParameters, char rootname, char *units, long rootnames, int64_t inputRow, long origPage)

void	GetAndOrganizeData (SDDS_DATASET SDDSin, COLLECTION collection, long collections, NEW_PARAMETER *newParameter, int newParameters)

char **	ConfirmMatchingColumns (COLLECTION collection, long collections, SDDS_DATASET SDDSin, SDDS_DATASET SDDSout, long rootnames, char ***units, long warnings)

int	main (int argc, char **argv)

Variables
static char *	USAGE

static char *	option [N_OPTIONS]

Detailed Description

Collects data from multiple columns into new grouped columns based on specified criteria.

The program processes SDDS (Self Describing Data Sets) files, allowing users to collect data from various input columns and organize them into new output columns with specified suffixes, prefixes, or matching patterns. It supports options for pipeline processing, controlling warnings, and setting the major order of the output data.

@usage sddscollect [options] [<input>] [<output>]

@options -pipe=[input][,output] Use the standard SDDS toolkit pipe option for input and output.

-collect={suffix=<string>|prefix=<string>|match=<string>}[,column=<newName>][,editCommand=<string>][,exclude=<wildcard>]... Collects columns based on the specified suffix, prefix, or matching pattern.

suffix: Selects columns ending with the given string.
prefix: Selects columns starting with the given string.
match: Selects columns matching the given wildcard pattern.
column: (Optional) Specifies the name of the new column. Defaults to the suffix or prefix.
editCommand: (Optional) Specifies a command to edit the column names.
exclude: (Optional) Excludes columns matching the given wildcard pattern.

-nowarnings Suppresses warning messages.

-majorOrder=row|column Specifies the major order of the output file. Can be either row-major or column-major.

Copyright

(c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
(c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License: This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author: M. Borland, R. Soliday, L. Emery

Definition in file sddscollect.c.

Macro Definition Documentation

◆ COLLECTION_COLUMN

#define COLLECTION_COLUMN 0x0004U

Definition at line 100 of file sddscollect.c.

◆ COLLECTION_EDIT

#define COLLECTION_EDIT 0x0010U

Definition at line 102 of file sddscollect.c.

◆ COLLECTION_EXCLUDE

#define COLLECTION_EXCLUDE 0x0020U

Definition at line 103 of file sddscollect.c.

◆ COLLECTION_MATCH

#define COLLECTION_MATCH 0x0008U

Definition at line 101 of file sddscollect.c.

◆ COLLECTION_PREFIX

#define COLLECTION_PREFIX 0x0002U

Definition at line 99 of file sddscollect.c.

◆ COLLECTION_SUFFIX

#define COLLECTION_SUFFIX 0x0001U

Definition at line 98 of file sddscollect.c.

Enumeration Type Documentation

◆ option_type

enum option_type

Definition at line 67 of file sddscollect.c.

                 {
  CLO_COLLECT,
  CLO_PIPE,
  CLO_NOWARNINGS,
  CLO_MAJOR_ORDER,
  N_OPTIONS
};

Function Documentation

◆ CollectAndWriteData()

void CollectAndWriteData	(	SDDS_DATASET *	SDDSout,
		COLLECTION *	collection,
		long	collections,
		NEW_PARAMETER *	newParameter,
		int	newParameters,
		char **	rootname,
		char **	units,
		long	rootnames,
		int64_t	inputRow,
		long	origPage )

Definition at line 249 of file sddscollect.c.

                                                                                        {
  long ic, ip, ir;
  if (rootnames) {
    if (!SDDS_SetColumn(SDDSout, SDDS_PASS_BY_VALUE | SDDS_SET_BY_NAME, rootname, rootnames, "Rootname")) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
    if (!SDDS_SetColumn(SDDSout, SDDS_PASS_BY_VALUE | SDDS_SET_BY_NAME, units, rootnames, "Units")) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
    for (ic = 0; ic < collections; ic++) {
      for (ir = 0; ir < rootnames; ir++) {
        if (!SDDS_SetRowValues(SDDSout, SDDS_PASS_BY_REFERENCE | SDDS_SET_BY_INDEX,
                               ir, collection[ic].targetIndex,
                               ((char *)(collection[ic].data[ir])) + inputRow * collection[ic].size, -1)) {
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
        }
      }
    }
  }
 
  for (ip = 0; ip < newParameters; ip++) {
    if (!SDDS_SetParameters(SDDSout, SDDS_PASS_BY_REFERENCE | SDDS_SET_BY_NAME,
                            newParameter[ip].name,
                            ((char *)(newParameter[ip].data) + inputRow * newParameter[ip].size), NULL)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
  }
  if (!SDDS_SetParameters(SDDSout, SDDS_PASS_BY_VALUE | SDDS_SET_BY_NAME,
                          "OriginalPage", origPage, NULL) ||
      !SDDS_WritePage(SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
}

◆ ConfirmMatchingColumns()

char ** ConfirmMatchingColumns	(	COLLECTION *	collection,
		long	collections,
		SDDS_DATASET *	SDDSin,
		SDDS_DATASET *	SDDSout,
		long *	rootnames,
		char ***	units,
		long	warnings )

Definition at line 430 of file sddscollect.c.

                                                                                                    {
  long ic, ip, ii, partLength;
  char **rootname, editBuffer[1024];
  char saveChar;
 
  partLength = 0;
  rootname = NULL;
  *units = NULL;
  *rootnames = 0;
  if (!collections)
    return NULL;
  for (ic = 0; ic < collections; ic++) {
    if (!collection[ic].oldColumns)
      continue;
    if (collection[ic].part)
      partLength = strlen(collection[ic].part);
    if (collection[ic].part && collection[ic].flags & COLLECTION_SUFFIX) {
      /* sort collection according to truncated string */
      saveChar = collection[ic].part[0];
      for (ip = 0; ip < collection[ic].oldColumns; ip++)
        collection[ic].oldColumn[ip][strlen(collection[ic].oldColumn[ip]) - partLength] = 0;
      qsort(collection[ic].oldColumn, collection[ic].oldColumns, sizeof(*collection[ic].oldColumn), string_cmpasc);
      /* now restore the strings (column names) to original form */
      for (ip = 0; ip < collection[ic].oldColumns; ip++)
        collection[ic].oldColumn[ip][strlen(collection[ic].oldColumn[ip])] = saveChar;
    } else {
      qsort(collection[ic].oldColumn, collection[ic].oldColumns, sizeof(*collection[ic].oldColumn), string_cmpasc);
    }
    if (rootname)
      continue;
    *rootnames = collection[ic].oldColumns;
    if (!(rootname = (char **)malloc(sizeof(*rootname) * (*rootnames)))) {
      SDDS_Bomb("Memory allocation failure");
    }
    if (!(*units = (char **)malloc(sizeof(**units) * (*rootnames)))) {
      SDDS_Bomb("Memory allocation failure");
    }
    for (ip = 0; ip < (*rootnames); ip++) {
      if (SDDS_GetColumnInformation(SDDSin, "units", *units + ip, SDDS_GET_BY_NAME, collection[ic].oldColumn[ip]) != SDDS_STRING) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
      if (collection[ic].flags & COLLECTION_EDIT) {
        strcpy(editBuffer, collection[ic].oldColumn[ip]);
        if (!edit_string(editBuffer, collection[ic].editCommand)) {
          SDDS_Bomb("Problem editing column name.");
        }
        SDDS_CopyString(rootname + ip, editBuffer);
      } else if (collection[ic].flags & COLLECTION_PREFIX) {
        SDDS_CopyString(rootname + ip, collection[ic].oldColumn[ip] + partLength);
      } else {
        SDDS_CopyString(rootname + ip, collection[ic].oldColumn[ip]);
        rootname[ip][strlen(rootname[ip]) - partLength] = 0;
      }
    }
  }
  if (!(*rootnames))
    return NULL;
 
  for (ic = 0; ic < collections; ic++) {
    if (!collection[ic].oldColumns)
      continue;
    if (collection[ic].oldColumns != (*rootnames)) {
      fprintf(stderr, "Error (sddscollect): Groups have different numbers of members\n");
      for (ip = 0; ip < collections; ip++) {
        fprintf(stderr, "%ld in %s\n", collection[ip].oldColumns,
                collection[ip].part ? collection[ip].part : collection[ip].match);
      }
      exit(EXIT_FAILURE);
    }
    if (collection[ic].flags & COLLECTION_MATCH)
      continue;
    for (ip = 0; ip < collection[ic].oldColumns; ip++)
      if (strstr(collection[ic].oldColumn[ip], rootname[ip]) == NULL) {
        fprintf(stderr, "Error (sddscollect): Mismatch with rootname %s for column %s in group %s\n",
                rootname[ip], collection[ic].oldColumn[ip],
                collection[ic].part ? collection[ic].part : collection[ic].match);
        /* about to bomb here, so it's okay to reuse these indices */
        for (ic = 0; ic < collections; ic++) {
          fprintf(stderr, "Group %s (%ld):\n",
                  collection[ic].part ? collection[ic].part : collection[ic].match, ic);
          for (ip = 0; ip < collection[ic].oldColumns; ip++)
            fprintf(stderr, "  old column[%ld] = %s\n", ip, collection[ic].oldColumn[ip]);
        }
        exit(EXIT_FAILURE);
      }
  }
 
  for (ic = 0; ic < collections; ic++) {
    char *units;
    int32_t type = 0;
    long unitsMismatch;
    if (!collection[ic].oldColumns)
      continue;
    if (!SDDS_TransferColumnDefinition(SDDSout, SDDSin, collection[ic].oldColumn[0], collection[ic].newColumn) ||
        (collection[ic].targetIndex = SDDS_GetColumnIndex(SDDSout, collection[ic].newColumn)) < 0 ||
        SDDS_GetColumnInformation(SDDSout, "units", &units, SDDS_GET_BY_NAME, collection[ic].newColumn) != SDDS_STRING ||
        SDDS_GetColumnInformation(SDDSout, "type", &type, SDDS_GET_BY_NAME, collection[ic].newColumn) != SDDS_LONG) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
    collection[ic].size = SDDS_GetTypeSize(type);
    unitsMismatch = 0;
    for (ii = 1; ii < collection[ic].oldColumns; ii++) {
      if (SDDS_CheckColumn(SDDSin, collection[ic].oldColumn[ii], NULL, type, stderr) == SDDS_CHECK_WRONGTYPE) {
        fprintf(stderr, "Error (sddscollect): Inconsistent data types for suffix/prefix/match %s\n",
                collection[ic].part ? collection[ic].part : collection[ic].match);
        exit(EXIT_FAILURE);
      }
      if (SDDS_CheckColumn(SDDSin, collection[ic].oldColumn[ii], units, type, NULL) == SDDS_CHECK_WRONGUNITS)
        unitsMismatch = 1;
    }
    if (unitsMismatch) {
      if (warnings)
        fprintf(stderr, "Warning (sddscollect): Inconsistent units for suffix/prefix %s\n", collection[ic].part);
      if (!SDDS_ChangeColumnInformation(SDDSout, "units", "?", SDDS_BY_NAME, collection[ic].newColumn)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
    }
  }
 
  return rootname;
}

◆ GetAndOrganizeData()

void GetAndOrganizeData	(	SDDS_DATASET *	SDDSin,
		COLLECTION *	collection,
		long	collections,
		NEW_PARAMETER *	newParameter,
		int	newParameters )

Definition at line 285 of file sddscollect.c.

                                                                        {
  long ic, ip, ii;
  for (ic = 0; ic < collections; ic++) {
    for (ii = 0; ii < collection[ic].oldColumns; ii++) {
      if (!(collection[ic].data[ii] = SDDS_GetInternalColumn(SDDSin, collection[ic].oldColumn[ii]))) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
    }
  }
  for (ip = 0; ip < newParameters; ip++) {
    if (!(newParameter[ip].data = SDDS_GetColumn(SDDSin, newParameter[ip].name))) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
  }
}

◆ InitializeOutput()

long InitializeOutput	(	SDDS_DATASET *	SDDSout,
		char *	output,
		SDDS_DATASET *	SDDSin,
		COLLECTION *	collection,
		long	collections,
		NEW_PARAMETER **	newParameter,
		int *	newParameters,
		char ***	rootname,
		char ***	units,
		long	warnings )

Definition at line 302 of file sddscollect.c.

                                                                                          {
  char **inputColumn, *partString;
  long partLength, *inputLength;
  int32_t inputColumns;
  short *inputUsed;
  long ic, ii, ip, inputsUsed, rootnames;
  char *matchString, *excludeString;
 
  partLength = 0;
  inputLength = NULL;
 
  if (!SDDS_InitializeOutput(SDDSout, SDDS_BINARY, 0, NULL, "sddscollect output", output) ||
      !SDDS_TransferAllParameterDefinitions(SDDSout, SDDSin, 0) ||
      !SDDS_TransferAllArrayDefinitions(SDDSout, SDDSin, 0)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
 
  if (!(inputColumn = SDDS_GetColumnNames(SDDSin, &inputColumns)) || inputColumns == 0) {
    SDDS_Bomb("No columns in input file");
  }
  if (!(inputUsed = (short *)calloc(inputColumns, sizeof(*inputUsed))) ||
      !(inputLength = (long *)calloc(inputColumns, sizeof(*inputLength)))) {
    SDDS_Bomb("Memory allocation failure");
  }
  for (ii = 0; ii < inputColumns; ii++)
    inputLength[ii] = strlen(inputColumn[ii]);
 
  inputsUsed = 0;
  matchString = NULL;
  excludeString = NULL;
  for (ic = 0; ic < collections; ic++) {
    if (!collection[ic].newColumn)
      SDDS_CopyString(&collection[ic].newColumn, collection[ic].part);
    if ((partString = collection[ic].part))
      partLength = strlen(partString);
    if (collection[ic].match) {
      matchString = collection[ic].match;
      partLength = -1;
    }
    if (collection[ic].exclude) {
      excludeString = collection[ic].exclude;
    }
    collection[ic].oldColumn = NULL;
    collection[ic].oldColumns = 0;
    for (ii = 0; ii < inputColumns; ii++) {
      if (inputUsed[ii])
        continue;
      if (partLength >= inputLength[ii])
        continue;
      if (matchString) {
        if (wild_match(inputColumn[ii], matchString)) {
          if ((excludeString == NULL) || (!wild_match(inputColumn[ii], excludeString))) {
            if (!(collection[ic].oldColumn = SDDS_Realloc(collection[ic].oldColumn,
                                                          sizeof(*collection[ic].oldColumn) * (collection[ic].oldColumns + 1)))) {
              SDDS_Bomb("Memory allocation failure");
            }
            collection[ic].oldColumn[collection[ic].oldColumns] = inputColumn[ii];
            inputUsed[ii] = 1;
            inputsUsed++;
            collection[ic].oldColumns++;
          }
        }
      } else if (collection[ic].flags & COLLECTION_PREFIX) {
        if (strncmp(partString, inputColumn[ii], partLength) == 0) {
          if (!(collection[ic].oldColumn = SDDS_Realloc(collection[ic].oldColumn,
                                                        sizeof(*collection[ic].oldColumn) * (collection[ic].oldColumns + 1)))) {
            SDDS_Bomb("Memory allocation failure");
          }
          collection[ic].oldColumn[collection[ic].oldColumns] = inputColumn[ii];
          inputUsed[ii] = 1;
          inputsUsed++;
          collection[ic].oldColumns++;
        }
      } else {
        if (strcmp(partString, inputColumn[ii] + inputLength[ii] - partLength) == 0) {
          if (!(collection[ic].oldColumn = SDDS_Realloc(collection[ic].oldColumn,
                                                        sizeof(*collection[ic].oldColumn) * (collection[ic].oldColumns + 1)))) {
            SDDS_Bomb("Memory allocation failure");
          }
          collection[ic].oldColumn[collection[ic].oldColumns] = inputColumn[ii];
          inputUsed[ii] = 1;
          inputsUsed++;
          collection[ic].oldColumns++;
        }
      }
    }
    if (!collection[ic].oldColumns && warnings) {
      fprintf(stderr, "Warning (sddscollect): No columns in input for %s %s\n",
              collection[ic].flags & COLLECTION_PREFIX ? "prefix" : "suffix", collection[ic].part);
    }
    if (!(collection[ic].data = (void **)calloc(collection[ic].oldColumns, sizeof(*collection[ic].data)))) {
      SDDS_Bomb("Memory allocation failure");
    }
  }
 
  if ((*newParameters = inputColumns - inputsUsed)) {
    *newParameter = (NEW_PARAMETER *)malloc(sizeof(**newParameter) * (*newParameters));
    for (ii = ip = 0; ii < inputColumns; ii++) {
      if (inputUsed[ii])
        continue;
      if (!SDDS_CopyString(&(*newParameter)[ip].name, inputColumn[ii]) ||
          !SDDS_DefineParameterLikeColumn(SDDSout, SDDSin, inputColumn[ii], NULL) ||
          ((*newParameter)[ip].targetIndex = SDDS_GetParameterIndex(SDDSout, inputColumn[ii])) < 0) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
      (*newParameter)[ip].size = SDDS_GetTypeSize(SDDS_GetParameterType(SDDSout, (*newParameter)[ip].targetIndex));
      ip++;
    }
  }
 
  *rootname = ConfirmMatchingColumns(collection, collections, SDDSin, SDDSout, &rootnames, units, warnings);
 
  if (SDDS_DefineParameter(SDDSout, "OriginalPage", NULL, NULL, NULL, NULL, SDDS_LONG, NULL) < 0) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
  if (rootnames &&
      (SDDS_DefineColumn(SDDSout, "Rootname", NULL, NULL, NULL, NULL, SDDS_STRING, 0) < 0 ||
       SDDS_DefineColumn(SDDSout, "Units", NULL, NULL, NULL, NULL, SDDS_STRING, 0) < 0)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
  if (!SDDS_WriteLayout(SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
  return rootnames;
}

◆ main()

int main	(	int	argc,
		char **	argv )

Definition at line 110 of file sddscollect.c.

                                {
  long iArg, ic;
  SDDS_DATASET SDDSin, SDDSout;
  SCANNED_ARG *scanned;
  unsigned long pipeFlags, flags, majorOrderFlag;
  COLLECTION *collection;
  NEW_PARAMETER *newParameter;
  char **rootname, **units;
  long collections, rootnames, code;
  int newParameters = 0;
  int64_t rows, row;
  char *input, *output;
  long warnings;
  short columnMajorOrder = -1;
 
  SDDS_RegisterProgramName(argv[0]);
 
  argc = scanargs(&scanned, argc, argv);
  if (argc == 1) {
    bomb(NULL, USAGE);
    return EXIT_FAILURE;
  }
 
  input = output = NULL;
  collection = NULL;
  collections = 0;
  pipeFlags = 0;
  warnings = 1;
 
  for (iArg = 1; iArg < argc; iArg++) {
    if (scanned[iArg].arg_type == OPTION) {
      /* process options here */
      switch (match_string(scanned[iArg].list[0], option, N_OPTIONS, 0)) {
      case CLO_MAJOR_ORDER:
        majorOrderFlag = 0;
        scanned[iArg].n_items--;
        if (scanned[iArg].n_items > 0 &&
            (!scanItemList(&majorOrderFlag, scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
                           "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
                           "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) {
          SDDS_Bomb("Invalid -majorOrder syntax/values");
        }
        if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
          columnMajorOrder = 1;
        else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
          columnMajorOrder = 0;
        break;
      case CLO_COLLECT:
        if (!(collection = SDDS_Realloc(collection, sizeof(*collection) * (collections + 1)))) {
          SDDS_Bomb("Memory allocation failure");
        }
        ic = collections;
        collection[ic].newColumn = collection[ic].part = collection[ic].match = collection[ic].editCommand = NULL;
        collection[ic].exclude = NULL;
        if (--scanned[iArg].n_items == 0 ||
            !scanItemList(&flags, scanned[iArg].list + 1, &scanned[iArg].n_items, 0,
                          "suffix", SDDS_STRING, &collection[ic].part, 1, COLLECTION_SUFFIX,
                          "prefix", SDDS_STRING, &collection[ic].part, 1, COLLECTION_PREFIX,
                          "column", SDDS_STRING, &collection[ic].newColumn, 1, COLLECTION_COLUMN,
                          "match", SDDS_STRING, &collection[ic].match, 1, COLLECTION_MATCH,
                          "editcommand", SDDS_STRING, &collection[ic].editCommand, 1, COLLECTION_EDIT,
                          "exclude", SDDS_STRING, &collection[ic].exclude, 1, COLLECTION_EXCLUDE, NULL) ||
            ((flags & COLLECTION_SUFFIX && flags & COLLECTION_PREFIX) ||
             (flags & COLLECTION_SUFFIX && flags & COLLECTION_MATCH) ||
             (flags & COLLECTION_PREFIX && flags & COLLECTION_MATCH))) {
          SDDS_Bomb("Invalid -collect syntax");
        }
        if (flags & COLLECTION_MATCH &&
            (!(flags & COLLECTION_EDIT) || !(flags & COLLECTION_COLUMN))) {
          SDDS_Bomb("Invalid -collect syntax: must give editCommand and column with match");
        }
        collection[ic].flags = flags;
        collections++;
        break;
      case CLO_PIPE:
        if (!processPipeOption(scanned[iArg].list + 1, scanned[iArg].n_items - 1, &pipeFlags)) {
          SDDS_Bomb("Invalid -pipe syntax");
        }
        break;
      case CLO_NOWARNINGS:
        warnings = 0;
        break;
      default:
        fprintf(stderr, "Invalid option seen: %s\n", scanned[iArg].list[0]);
        exit(EXIT_FAILURE);
        break;
      }
    } else {
      if (!input)
        input = scanned[iArg].list[0];
      else if (!output)
        output = scanned[iArg].list[0];
      else
        SDDS_Bomb("Too many filenames");
    }
  }
 
  if (!collections) {
    SDDS_Bomb("At least one -collect option must be given");
  }
 
  processFilenames("sddscollect", &input, &output, pipeFlags, !warnings, NULL);
 
  if (!SDDS_InitializeInput(&SDDSin, input)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
 
  rootnames = InitializeOutput(&SDDSout, output, &SDDSin, collection, collections,
                               &newParameter, &newParameters, &rootname, &units, warnings);
  if (columnMajorOrder != -1)
    SDDSout.layout.data_mode.column_major = columnMajorOrder;
  else
    SDDSout.layout.data_mode.column_major = SDDSin.layout.data_mode.column_major;
 
  while ((code = SDDS_ReadPage(&SDDSin)) > 0) {
    if (!SDDS_StartPage(&SDDSout, rootnames) ||
        !SDDS_CopyParameters(&SDDSout, &SDDSin) ||
        !SDDS_CopyArrays(&SDDSout, &SDDSin)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
    if ((rows = SDDS_CountRowsOfInterest(&SDDSin)) > 0) {
      GetAndOrganizeData(&SDDSin, collection, collections, newParameter, newParameters);
      for (row = 0; row < rows; row++) {
        CollectAndWriteData(&SDDSout, collection, collections, newParameter, newParameters,
                            rootname, units, rootnames, row, code);
        if (row != rows - 1 && !SDDS_StartPage(&SDDSout, rootnames)) {
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
        }
      }
    } else if (!SDDS_WritePage(&SDDSout)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
  }
  if (!code || !SDDS_Terminate(&SDDSout) || !SDDS_Terminate(&SDDSin)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
  return EXIT_SUCCESS;
}

Variable Documentation

◆ option

char* option[N_OPTIONS]

static

Initial value:

= {
  "collect",
  "pipe",
  "nowarnings",
  "majorOrder",
}

Definition at line 75 of file sddscollect.c.

                                 {
  "collect",
  "pipe",
  "nowarnings",
  "majorOrder",
};

◆ USAGE

char* USAGE