Reorganizes column data from an SDDS file onto separate pages. More...

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

Classes
struct	groups_t

Enumerations
enum	option_type_t { SET_GROUP , SET_COPY , SET_PIPE , N_OPTIONS }

Functions
int	main (int argc, char **argv)

Variables
static char *	option_strings [N_OPTIONS]

static char *	usage_message

Detailed Description

Reorganizes column data from an SDDS file onto separate pages.

This program reads an SDDS (Self Describing Data Set) file and reorganizes the column data such that data from different columns ends up on separate pages. The user can specify groups of columns to be combined under a new name, or copy columns across pages.

Features:

Group columns under a common name.
Copy specified columns across all pages.
Handle input and output through piping for flexibility.

Usage:

sddsseparate [<inputfile>] [<outputfile>] [-pipe=[input][,output]] [-group=<newName>,<listOfOldNames>] [-copy=<listOfNames>]

Options:

-pipe: Enables piping for input and/or output.
-group: Groups multiple old column names under a new column name. Data from the old columns will appear on sequential pages under the new name.
-copy: Specifies columns to be copied across all pages.

Example:

To group columns A, B, C under a new column name "Group1" and copy column D: sddsseparate input.sdds output.sdds -group=Group1,A,B,C -copy=D

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.

Authors

M. Borland
R. Soliday
H. Shang

Definition in file sddsseparate.c.

Enumeration Type Documentation

◆ option_type_t

enum option_type_t

Definition at line 55 of file sddsseparate.c.

             {
  SET_GROUP,
  SET_COPY,
  SET_PIPE,
  N_OPTIONS
} option_type_t;

Function Documentation

◆ main()

int main	(	int	argc,
		char **	argv )

Definition at line 89 of file sddsseparate.c.

                                {
  char *input = NULL;
  char *output = NULL;
  char **copy_column_name = NULL;
  char **users_copy_column_name = NULL;
  groups_t *group = NULL;
  int32_t copy_columns = 0;
  long users_copy_columns = 0;
  long groups_count = 0;
  long i_arg, i, read_code, items;
  int64_t rows;
  unsigned long pipe_flags = 0;
  SCANNED_ARG *sc_arg = NULL;
  SDDS_DATASET sdds_in, sdds_out;
 
  /* Register the program name for error reporting */
  SDDS_RegisterProgramName(argv[0]);
 
  /* Parse command-line arguments */
  argc = scanargs(&sc_arg, argc, argv);
  if (argc < 2)
    bomb(usage_message, NULL);
 
  /* Initialize variables */
  group = NULL;
  copy_column_name = users_copy_column_name = NULL;
  users_copy_columns = copy_columns = groups_count = 0;
 
  /* Process arguments */
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (sc_arg[i_arg].arg_type == OPTION) {
      /* Match options and process accordingly */
      switch (match_string(sc_arg[i_arg].list[0], option_strings, N_OPTIONS, 0)) {
      case SET_PIPE:
        /* Handle pipe options */
        if (!processPipeOption(sc_arg[i_arg].list + 1, sc_arg[i_arg].n_items - 1, &pipe_flags))
          SDDS_Bomb("invalid -pipe syntax");
        break;
 
      case SET_GROUP:
        /* Handle group options */
        items = sc_arg[i_arg].n_items - 1;
        if (items < 2)
          SDDS_Bomb("invalid -group syntax");
        group = SDDS_Realloc(group, sizeof(*group) * (groups_count + 1));
        if (!group ||
            !SDDS_CopyString(&group[groups_count].new_name, sc_arg[i_arg].list[1]) ||
            !(group[groups_count].users_old_name = SDDS_Malloc(sizeof(*group[groups_count].users_old_name) * (group[groups_count].users_old_names = items - 1))) ||
            !SDDS_CopyStringArray(group[groups_count].users_old_name, sc_arg[i_arg].list + 2, group[groups_count].users_old_names))
          SDDS_Bomb("memory allocation failure");
        group[groups_count].old_name = NULL;
        group[groups_count].old_names = 0;
        groups_count++;
        break;
 
      case SET_COPY:
        /* Handle copy options */
        if (users_copy_columns)
          SDDS_Bomb("give -copy only once");
        users_copy_columns = sc_arg[i_arg].n_items - 1;
        if (users_copy_columns < 1)
          SDDS_Bomb("invalid -copy syntax");
        users_copy_column_name = SDDS_Malloc(sizeof(*users_copy_column_name) * users_copy_columns);
        if (!users_copy_column_name ||
            !SDDS_CopyStringArray(users_copy_column_name, sc_arg[i_arg].list + 1, users_copy_columns))
          SDDS_Bomb("memory allocation failure");
        break;
 
      default:
        /* Handle unknown options */
        fprintf(stderr, "error: unknown/ambiguous option: %s\n", sc_arg[i_arg].list[0]);
        exit(EXIT_FAILURE);
        break;
      }
    } else {
      /* Process input and output filenames */
      if (!input)
        input = sc_arg[i_arg].list[0];
      else if (!output)
        output = sc_arg[i_arg].list[0];
      else
        SDDS_Bomb("too many filenames seen");
    }
  }
 
  if (groups_count == 0)
    SDDS_Bomb("no groups defined");
 
  /* Process filenames and open input file */
  processFilenames("sddsseparate", &input, &output, pipe_flags, 0, NULL);
 
  if (!SDDS_InitializeInput(&sdds_in, input))
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
  /* Process copy columns */
  if (users_copy_columns) {
    SDDS_SetColumnFlags(&sdds_in, 0);
    for (i = 0; i < users_copy_columns; i++)
      SDDS_SetColumnsOfInterest(&sdds_in, SDDS_MATCH_STRING, users_copy_column_name[i], SDDS_OR);
    copy_column_name = SDDS_GetColumnNames(&sdds_in, &copy_columns);
    if (!copy_column_name || copy_columns == 0)
      SDDS_Bomb("no match for copy columns");
  }
 
  /* Process groups */
  for (i = 0; i < groups_count; i++) {
    long j, type = 0;
    SDDS_SetColumnFlags(&sdds_in, 0);
 
    for (j = 0; j < group[i].users_old_names; j++)
      SDDS_SetColumnsOfInterest(&sdds_in, SDDS_MATCH_STRING, group[i].users_old_name[j], SDDS_OR);
 
    group[i].old_name = SDDS_GetColumnNames(&sdds_in, &group[i].old_names);
    if (!group[i].old_name) {
      fprintf(stderr, "No match for group %s (sddsseparate)\n", group[i].new_name);
      exit(EXIT_FAILURE);
    }
 
    if (i > 0 && group[i - 1].old_names != group[i].old_names) {
      fprintf(stderr, "Group %s comprises %" PRId32 " columns, whereas the last group comprises %" PRId32 " (sddsseparate)\n",
              group[i].new_name, group[i].old_names, group[i - 1].old_names);
      exit(EXIT_FAILURE);
    }
 
    type = SDDS_GetColumnType(&sdds_in, SDDS_GetColumnIndex(&sdds_in, group[i].old_name[0]));
    for (j = 1; j < group[i].old_names; j++) {
      if (type != SDDS_GetColumnType(&sdds_in, SDDS_GetColumnIndex(&sdds_in, group[i].old_name[j]))) {
        fprintf(stderr, "Inconsistent data types in group %s (sddsseparate)\n", group[i].new_name);
        fprintf(stderr, "First inconsistent column is %s\n", group[i].old_name[j]);
        exit(EXIT_FAILURE);
      }
    }
  }
 
  /* Initialize output file */
  if (!SDDS_InitializeOutput(&sdds_out, SDDS_BINARY, 0, NULL, NULL, output) ||
      !SDDS_TransferAllParameterDefinitions(&sdds_out, &sdds_in, 0))
    SDDS_Bomb("problem initializing output file");
 
  for (i = 0; i < copy_columns; i++) {
    if (!SDDS_TransferColumnDefinition(&sdds_out, &sdds_in, copy_column_name[i], NULL))
      SDDS_Bomb("problem transferring copy column definitions to output file");
  }
 
  for (i = 0; i < groups_count; i++) {
    char *name;
    if (!SDDS_TransferColumnDefinition(&sdds_out, &sdds_in, group[i].old_name[0], group[i].new_name)) {
      fprintf(stderr, "Problem transferring column %s as %s to output file (sddsseparate)\n",
              group[i].old_name[0], group[i].new_name);
      exit(EXIT_FAILURE);
    }
 
    group[i].parameter_name = SDDS_Malloc(sizeof(*name) * (strlen(group[i].new_name) + 100));
    if (!group[i].parameter_name)
      SDDS_Bomb("memory allocation failure");
 
    sprintf(group[i].parameter_name, "%sSourceColumn", group[i].new_name);
    if (!SDDS_DefineSimpleParameter(&sdds_out, group[i].parameter_name, NULL, SDDS_STRING))
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
 
  if (!SDDS_WriteLayout(&sdds_out))
    SDDS_Bomb("problem writing layout to output file");
 
  /* Process each page */
  while ((read_code = SDDS_ReadPage(&sdds_in)) > 0) {
    rows = SDDS_CountRowsOfInterest(&sdds_in);
    if (rows < 0)
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    if (rows == 0)
      continue;
 
    for (i = 0; i < group[0].old_names; i++) {
      long ic, ig;
 
      if (!SDDS_StartPage(&sdds_out, rows) ||
          !SDDS_CopyParameters(&sdds_out, &sdds_in))
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
      for (ic = 0; ic < copy_columns; ic++) {
        void *data = SDDS_GetInternalColumn(&sdds_in, copy_column_name[ic]);
        if (!data ||
            !SDDS_SetColumn(&sdds_out, SDDS_SET_BY_NAME, data, rows, copy_column_name[ic]))
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
 
      for (ig = 0; ig < groups_count; ig++) {
        void *data;
 
        if (!SDDS_SetParameters(&sdds_out, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE,
                                group[ig].parameter_name, group[ig].old_name[i], NULL))
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
        data = SDDS_GetInternalColumn(&sdds_in, group[ig].old_name[i]);
        if (!data ||
            !SDDS_SetColumn(&sdds_out, SDDS_SET_BY_NAME, data, rows, group[ig].new_name))
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
 
      if (!SDDS_WritePage(&sdds_out))
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
    }
  }
 
  /* Terminate input and output files */
  if (!SDDS_Terminate(&sdds_in)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
 
  if (!SDDS_Terminate(&sdds_out)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
 
  return 0;
}

Variable Documentation

◆ option_strings

char* option_strings[N_OPTIONS]

static

Initial value:

= {
  "group",
  "copy",
  "pipe",
}

Definition at line 63 of file sddsseparate.c.

                                         {
  "group",
  "copy",
  "pipe",
};

◆ usage_message

char* usage_message