sdds2headlessdata.c File Reference

Detailed Description

Converts SDDS files into binary data without headers.

This program reads an SDDS (Self Describing Data Set) file, extracts specified columns, and writes the data to a binary file in either row-major or column-major order. It supports flexible options for specifying columns, output order, and piping data. At least one column must be specified using -column. The program ensures compatibility of options and processes the input accordingly.

Usage

sdds2headlessdata [<input>] [<output>]
                  [-pipe=in|out]
                   -column=<name>
                  [-order={rowMajor|columnMajor}] 

Options

Required	Description
-column	Specifies the columns to include in the output.

Optional	Description
-pipe	Allows piping data into or out of the program.
-order	Specifies the output order for column data, either row-major or column-major order.

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

R. Soliday

Definition in file sdds2headlessdata.c.

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

Go to the source code of this file.

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

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 86 of file sdds2headlessdata.c.

                                {
  FILE *file_id;
  SDDS_FILEBUFFER *f_buffer = NULL;
 
  SDDS_DATASET sdds_dataset, sdds_dummy;
  SCANNED_ARG *s_arg;
  long j, i_arg, retval, page_number = 0, size, column_order = 0;
  int64_t i, rows = 0;
  char *input = NULL, *output = NULL;
  unsigned long pipe_flags = 0;
  long no_warnings = 0, tmpfile_used = 0;
 
  long *column_type = NULL, *column_index = NULL;
  void **column_data = NULL;
  char **column = NULL, **column_match = NULL;
  int32_t column_matches = 0;
  int32_t columns = 0;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 3) {
    bomb(NULL, usage);
  }
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_ORDER:
        if (s_arg[i_arg].n_items != 2) {
          SDDS_Bomb("invalid -order syntax");
        }
        switch (match_string(s_arg[i_arg].list[1], order_names, ORDERS, 0)) {
        case ROW_ORDER:
          column_order = 0;
          break;
        case COLUMN_ORDER:
          column_order = 1;
          break;
        default:
          SDDS_Bomb("invalid -order syntax");
          break;
        }
        break;
      case SET_COLUMN:
        if ((s_arg[i_arg].n_items < 2)) {
          SDDS_Bomb("invalid -column syntax");
        }
        column_matches = s_arg[i_arg].n_items - 1;
        column_match = tmalloc(sizeof(*column_match) * column_matches);
        for (i = 0; i < column_matches; i++) {
          column_match[i] = s_arg[i_arg].list[i + 1];
        }
        break;
      case SET_PIPE:
        if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipe_flags)) {
          fprintf(stderr, "Error (%s): invalid -pipe syntax\n", argv[0]);
          return 1;
        }
        break;
      default:
        fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]);
        exit(1);
      }
    } else {
      if (input == NULL) {
        input = s_arg[i_arg].list[0];
      } else if (output == NULL) {
        output = s_arg[i_arg].list[0];
      } else {
        fprintf(stderr, "too many filenames");
        exit(1);
      }
    }
  }
 
  processFilenames("sdds2headlessdata", &input, &output, pipe_flags, no_warnings, &tmpfile_used);
 
  if (!column_matches) {
    SDDS_Bomb("you must specify -column options");
  }
 
  if (!SDDS_InitializeInput(&sdds_dataset, input)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  column = getMatchingSDDSNames(&sdds_dataset, column_match, column_matches, &columns, SDDS_MATCH_COLUMN);
  if (!columns) {
    SDDS_Bomb("No columns found in the input file.");
  }
 
  column_type = tmalloc(sizeof(*column_type) * columns);
  column_index = tmalloc(sizeof(*column_index) * columns);
  column_data = tmalloc(sizeof(*column_data) * columns);
  for (i = 0; i < columns; i++) {
    if ((column_index[i] = SDDS_GetColumnIndex(&sdds_dataset, column[i])) < 0) {
      fprintf(stderr, "error: column %s does not exist\n", column[i]);
      exit(1);
    }
    if ((column_type[i] = SDDS_GetColumnType(&sdds_dataset, column_index[i])) <= 0) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      exit(1);
    }
  }
 
  if (!output) {
#ifdef _WIN32
    if (_setmode(_fileno(stdout), _O_BINARY) == -1) {
      fprintf(stderr, "error: unable to set stdout to binary mode\n");
      exit(1);
    }
#endif
    file_id = stdout;
  } else {
    file_id = fopen(output, "wb");
  }
  if (file_id == NULL) {
    fprintf(stderr, "unable to open output file for writing\n");
    exit(1);
  }
 
  f_buffer = &sdds_dummy.fBuffer;
  f_buffer->buffer = NULL;
  if (!f_buffer->buffer) {
    if (!(f_buffer->buffer = f_buffer->data = SDDS_Malloc(sizeof(char) * SDDS_FILEBUFFER_SIZE))) {
      fprintf(stderr, "Unable to do buffered read--allocation failure\n");
      exit(1);
    }
    f_buffer->bufferSize = SDDS_FILEBUFFER_SIZE;
    f_buffer->bytesLeft = SDDS_FILEBUFFER_SIZE;
  }
 
  retval = -1;
 
  while (retval != page_number && (retval = SDDS_ReadPage(&sdds_dataset)) > 0) {
    if (page_number && retval != page_number) {
      continue;
    }
    if ((rows = SDDS_CountRowsOfInterest(&sdds_dataset)) < 0) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      exit(1);
    }
    if (rows) {
      if (column_order) {
        for (j = 0; j < columns; j++) {
          if (column_type[j] == SDDS_STRING) {
            for (i = 0; i < rows; i++) {
              if (!SDDS_WriteBinaryString(*((char **)sdds_dataset.data[column_index[j]] + i), file_id, f_buffer)) {
                fprintf(stderr, "Unable to write rows--failure writing string\n");
                exit(1);
              }
            }
          } else {
            size = SDDS_type_size[column_type[j] - 1];
            for (i = 0; i < rows; i++) {
              if (!SDDS_BufferedWrite((char *)sdds_dataset.data[column_index[j]] + i * size, size, file_id, f_buffer)) {
                fprintf(stderr, "Unable to write rows--failure writing string\n");
                exit(1);
              }
            }
          }
        }
      } else {
        for (i = 0; i < rows; i++) {
          for (j = 0; j < columns; j++) {
            if (column_type[j] == SDDS_STRING) {
              if (!SDDS_WriteBinaryString(*((char **)sdds_dataset.data[column_index[j]] + i), file_id, f_buffer)) {
                fprintf(stderr, "Unable to write rows--failure writing string\n");
                exit(1);
              }
            } else {
              size = SDDS_type_size[column_type[j] - 1];
              if (!SDDS_BufferedWrite((char *)sdds_dataset.data[column_index[j]] + i * size, size, file_id, f_buffer)) {
                fprintf(stderr, "Unable to write rows--failure writing string\n");
                exit(1);
              }
            }
          }
        }
      }
    }
    if (retval == 0) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      exit(1);
    }
  }
  if (!SDDS_FlushBuffer(file_id, f_buffer)) {
    SDDS_SetError("Unable to write page--buffer flushing problem (SDDS_WriteBinaryPage)");
    return 0;
  }
  fclose(file_id);
 
  if (!SDDS_Terminate(&sdds_dataset)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
  exit(0);
}