int32_t SDDS_TransferAllArrayDefinitions(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source,
uint32_t mode)
{
SDDS_LAYOUT *target, *source;
int32_t i;
if (!SDDS_CheckDataset(SDDS_target, "SDDS_TransferAllArrayDefinitions"))
return(0);
if (!SDDS_CheckDataset(SDDS_source, "SDDS_TransferAllArrayDefinitions"))
return(0);
if (mode) {
/* haven't done this one yet */
SDDS_SetError("Nonzero mode not supported for arrays (SDDS_TransferAllArrayDefinitions)");
return 0;
}
target = &SDDS_target->layout;
source = &SDDS_source->layout;
SDDS_DeferSavingLayout(1);
for (i=0; i<source->n_arrays; i++)
if (SDDS_DefineArray(SDDS_target, source->array_definition[i].name, source->array_definition[i].symbol,
source->array_definition[i].units, source->array_definition[i].description,
source->array_definition[i].format_string, source->array_definition[i].type,
source->array_definition[i].field_length,
source->array_definition[i].dimensions,
source->array_definition[i].group_name)<0) {
SDDS_SetError("Unable to define parameter (SDDS_TransferAllArrayDefinitions)");
SDDS_DeferSavingLayout(0);
return 0;
}
SDDS_DeferSavingLayout(0);
return 1;
}
int32_t SDDS_TransferAllColumnDefinitions(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source,
uint32_t mode)
{
SDDS_LAYOUT *target, *source;
int32_t i, index;
char messBuffer[1024];
if (!SDDS_CheckDataset(SDDS_target, "SDDS_TransferAllColumnDefinitions"))
return(0);
if (!SDDS_CheckDataset(SDDS_source, "SDDS_TransferAllColumnDefinitions"))
return(0);
if (mode&SDDS_TRANSFER_KEEPOLD && mode&SDDS_TRANSFER_OVERWRITE) {
SDDS_SetError("Inconsistent mode flags (SDDS_TransferAllColumnDefinitions)");
return 0;
}
target = &SDDS_target->layout;
source = &SDDS_source->layout;
SDDS_DeferSavingLayout(1);
for (i=0; i<source->n_columns; i++)
if ((index=SDDS_GetParameterIndex(SDDS_target, source->parameter_definition[i].name))>=0) {
/* already exists */
if (mode&SDDS_TRANSFER_KEEPOLD)
continue;
if (!(mode&SDDS_TRANSFER_OVERWRITE)) {
sprintf(messBuffer,
"Unable to define parameter %s---already exists (SDDS_TransferAllParameterDefinitions)",
source->parameter_definition[i].name);
SDDS_SetError(messBuffer);
SDDS_DeferSavingLayout(0);
return 0;
}
if (source->column_definition[i].type!=target->column_definition[index].type
&& SDDS_target->n_rows_allocated) {
sprintf(messBuffer,
"Unable to define parameter %s---type mismatch and table already allocated (SDDS_TransferAllParameterDefinitions)",
source->parameter_definition[i].name);
SDDS_SetError(messBuffer);
SDDS_DeferSavingLayout(0);
return 0;
}
if (!SDDS_ChangeColumnInformation(SDDS_target, "symbol",
&source->column_definition[i].symbol,
SDDS_BY_INDEX, index) ||
!SDDS_ChangeColumnInformation(SDDS_target, "units",
&source->column_definition[i].units,
SDDS_BY_INDEX, index) ||
!SDDS_ChangeColumnInformation(SDDS_target, "description",
&source->column_definition[i].description,
SDDS_BY_INDEX, index) ||
!SDDS_ChangeColumnInformation(SDDS_target, "format_string",
&source->column_definition[i].format_string,
SDDS_BY_INDEX, index) ||
!SDDS_ChangeColumnInformation(SDDS_target, "type",
&source->column_definition[i].type,
SDDS_BY_INDEX, index) ||
!SDDS_ChangeColumnInformation(SDDS_target, "field_length",
&source->column_definition[i].field_length,
SDDS_BY_INDEX, index)) {
SDDS_SetError("Unable to define column---problem with overwrite (SDDS_TransferAllColumnDefinitions)");
SDDS_DeferSavingLayout(0);
return 0;
}
target->column_definition[index].definition_mode =
source->column_definition[index].definition_mode;
if (target->column_definition[index].type==SDDS_STRING)
target->column_definition[index].memory_number =
SDDS_CreateRpnMemory(source->column_definition[i].name, 1);
else
target->column_definition[index].memory_number =
SDDS_CreateRpnMemory(source->column_definition[i].name, 0);
} else {
if (SDDS_DefineColumn(SDDS_target, source->column_definition[i].name, source->column_definition[i].symbol,
source->column_definition[i].units, source->column_definition[i].description,
source->column_definition[i].format_string, source->column_definition[i].type,
source->column_definition[i].field_length)<0) {
SDDS_SetError("Unable to define column (SDDS_TransferAllColumnDefinitions)");
SDDS_DeferSavingLayout(0);
return 0;
}
}
SDDS_DeferSavingLayout(0);
return 1;
}
int32_t SDDS_CopyLayout(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source)
{
SDDS_LAYOUT *target, *source;
int32_t i;
if (!SDDS_CheckDataset(SDDS_target, "SDDS_CopyLayout"))
return(0);
if (!SDDS_CheckDataset(SDDS_source, "SDDS_CopyLayout"))
return(0);
target = &SDDS_target->layout;
source = &SDDS_source->layout;
target->version = source->version;
target->data_mode = source->data_mode;
target->data_mode.no_row_counts = 0;
target->data_mode.fixed_row_count = 0;
target->layout_written = 0;
target->byteOrderDeclared = 0;
if (source->description)
SDDS_CopyString(&target->description, source->description);
if (source->contents)
SDDS_CopyString(&target->contents, source->contents);
SDDS_DeferSavingLayout(1);
for (i=0; i<source->n_columns; i++)
if (SDDS_DefineColumn(SDDS_target, source->column_definition[i].name, source->column_definition[i].symbol,
source->column_definition[i].units, source->column_definition[i].description,
source->column_definition[i].format_string, source->column_definition[i].type,
source->column_definition[i].field_length)<0) {
SDDS_SetError("Unable to define column (SDDS_CopyLayout)");
return(0);
}
for (i=0; i<source->n_parameters; i++)
if (SDDS_DefineParameter(SDDS_target, source->parameter_definition[i].name, source->parameter_definition[i].symbol,
source->parameter_definition[i].units, source->parameter_definition[i].description,
source->parameter_definition[i].format_string, source->parameter_definition[i].type,
source->parameter_definition[i].fixed_value)<0) {
SDDS_SetError("Unable to define parameter (SDDS_CopyLayout)");
return(0);
}
for (i=0; i<source->n_associates; i++)
if (SDDS_DefineAssociate(SDDS_target, source->associate_definition[i].name,
source->associate_definition[i].filename,
source->associate_definition[i].path,
source->associate_definition[i].description,
source->associate_definition[i].contents, source->associate_definition[i].sdds)<0) {
SDDS_SetError("Unable to define associate (SDDS_CopyLayout)");
return(0);
}
for (i=0; i<source->n_arrays; i++)
if (SDDS_DefineArray(SDDS_target, source->array_definition[i].name, source->array_definition[i].symbol,
source->array_definition[i].units, source->array_definition[i].description,
source->array_definition[i].format_string, source->array_definition[i].type,
source->array_definition[i].field_length, source->array_definition[i].dimensions,
source->array_definition[i].group_name)<0) {
SDDS_SetError("Unable to define array (SDDS_CopyLayout)");
return(0);
}
SDDS_DeferSavingLayout(0);
if (!SDDS_SaveLayout(SDDS_target)) {
SDDS_SetError("Unable to save layout (SDDS_CopyLayout)");
return(0);
}
return(1);
}
int main(int argc, char **argv)
{
SCANNED_ARG *s_arg;
SDDS_DATASET inputPage, outputPage;
char *inputfile, *outputfile;
char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName;
char **outputStringColumnName, **outputDoubleColumnName, **matchColumn=NULL;
long inputRows, inputDoubleColumns, inputStringColumns, indexColumn=0, matchColumns=0, noOldColumnNamesColumn=0;
long outputRows, outputDoubleColumns, outputStringColumns;
char **inputParameterName;
int32_t inputParameters, inputColumns;
char *inputDescription, *inputContents;
char *outputDescription;
long i, i_arg, col;
char *buffer;
char **columnOfStrings;
long buffer_size;
#define BUFFER_SIZE_INCREMENT 16384
MATRIX *R, *RInv;
long OldStringColumnsDefined;
char *inputStringRows, *outputStringRows;
char **stringArray, *stringParameter;
long token_length;
long verbose;
char format[32];
long digits;
char *Symbol, *Root;
void *parameterPointer;
long ascii;
unsigned long pipeFlags, majorOrderFlag;
long tmpfile_used, noWarnings;
long ipage=0, columnType;
char *oldColumnNames, *newColumnNamesColumn;
short columnMajorOrder=-1;
inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL;
outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&s_arg, argc, argv);
if (argc==1)
bomb(NULL, USAGE);
inputfile = outputfile = NULL;
verbose = 0;
Symbol = Root = NULL;
ascii = 0;
digits=3;
pipeFlags = 0;
tmpfile_used = 0;
noWarnings = 0;
oldColumnNames = NULL;
newColumnNamesColumn = NULL;
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], commandline_option, COMMANDLINE_OPTIONS,
UNIQUE_MATCH)) {
case CLO_MAJOR_ORDER:
majorOrderFlag=0;
s_arg[i_arg].n_items--;
if (s_arg[i_arg].n_items>0 &&
(!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[i_arg].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_MATCH_COLUMN:
matchColumns = s_arg[i_arg].n_items-1;
matchColumn = s_arg[i_arg].list+1;
break;
case CLO_INDEX_COLUMN:
indexColumn = 1;
break;
case CLO_NO_OLDCOLUMNNAMES:
noOldColumnNamesColumn = 1;
break;
case CLO_VERBOSE:
verbose=1;
break;
case CLO_ASCII:
ascii=1;
break;
case CLO_DIGITS:
if (!(get_long(&digits, s_arg[i_arg].list[1])))
bomb("no string given for option -digits", USAGE);
break;
case CLO_COLUMNROOT:
if (!(Root=s_arg[i_arg].list[1]))
SDDS_Bomb("No root string given");
break;
case CLO_SYMBOL:
if (!(Symbol=s_arg[i_arg].list[1]))
SDDS_Bomb("No symbol string given");
break;
case CLO_PIPE:
if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags))
SDDS_Bomb("invalid -pipe syntax");
break;
case CLO_OLDCOLUMNNAMES:
if (!(oldColumnNames=s_arg[i_arg].list[1]))
SDDS_Bomb("No oldColumnNames string given");
break;
case CLO_NEWCOLUMNNAMES:
if (s_arg[i_arg].n_items!=2 ||
SDDS_StringIsBlank(newColumnNamesColumn = s_arg[i_arg].list[1]))
SDDS_Bomb("Invalid -newColumnNames syntax/value");
break;
default:
bomb("unrecognized option given", USAGE);
}
}
else {
if (!inputfile)
inputfile = s_arg[i_arg].list[0];
else if (!outputfile)
outputfile = s_arg[i_arg].list[0];
else
bomb("too many filenames given", USAGE);
}
}
processFilenames("sddstranpose", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used);
if (newColumnNamesColumn && Root)
SDDS_Bomb("-root and -newColumnNames are incompatible");
if (!SDDS_InitializeInput(&inputPage, inputfile) ||
!(inputParameterName=(char**)SDDS_GetParameterNames(&inputPage, &inputParameters)) ||
!SDDS_GetDescription(&inputPage, &inputDescription, &inputContents))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
if (matchColumns)
inputColumnName = getMatchingSDDSNames(&inputPage, matchColumn, matchColumns, &inputColumns, SDDS_MATCH_COLUMN);
else {
if (!(inputColumnName=(char**)SDDS_GetColumnNames(&inputPage, &inputColumns)))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
}
inputDoubleColumns=0;
inputStringColumns=0;
inputDoubleColumnName=(char**)malloc(inputColumns*sizeof(char*));
inputStringColumnName=(char**)malloc(inputColumns*sizeof(char*));
inputRows = 0;
/*********** \
* read data *
\***********/
while (0<SDDS_ReadTable(&inputPage)) {
ipage ++;
#if defined(DEBUG)
fprintf(stderr, "working on page %ld\n", ipage);
#endif
if (ipage==1) {
SDDS_DeferSavingLayout(1);
if( !SDDS_SetColumnFlags(&inputPage, 0))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
/* count the string and numerical columns in the input file */
for (i=0;i<inputColumns;i++) {
if ( SDDS_NUMERIC_TYPE( columnType = SDDS_GetColumnType( &inputPage, i))) {
inputDoubleColumnName[inputDoubleColumns]=inputColumnName[i];
inputDoubleColumns++;
}
}
for (i=0; i<inputPage.layout.n_columns; i++) {
if (inputPage.layout.column_definition[i].type == SDDS_STRING ) {
inputStringColumnName[inputStringColumns] = inputPage.layout.column_definition[i].name;
inputStringColumns++;
}
}
if( !(inputRows=SDDS_CountRowsOfInterest(&inputPage)))
SDDS_Bomb("No rows in dataset.");
}
else {
/* these statements are executed on the subsequent pages */
if (inputRows != SDDS_CountRowsOfInterest(&inputPage)) {
SDDS_Bomb("Datasets don't have the same number of rows.\nProcessing stopped before reaching the end of the input file.");
}
}
#if defined(DEBUG)
fprintf(stderr, "row flags set\n");
#endif
if (inputDoubleColumns == 0)
SDDS_Bomb("No numerical columns in file.");
if ((ipage==1) && verbose) {
fprintf(stderr, "No. of double/float/integer columns: %ld.\n", inputDoubleColumns);
fprintf(stderr, "No. of string columns: %ld.\n", inputStringColumns);
fprintf(stderr, "No. of rows: %ld.\n", inputRows);
}
/****************\
* transpose data *
\****************/
if (inputDoubleColumns) {
if (ipage == 1) {
m_alloc(&RInv, inputRows, inputDoubleColumns);
m_alloc(&R, inputDoubleColumns, inputRows);
}
for (col=0;col<inputDoubleColumns;col++){
if (!(R->a[col]=(double*)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) {
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
if (verbose) {
m_show(R, "%9.6le ", "Transpose of input matrix:\n", stdout);
}
m_trans(RInv, R);
}
/***************************\
* determine existence of *
* transposed string columns *
\***************************/
if (ipage == 1) {
OldStringColumnsDefined=0;
switch(SDDS_CheckParameter(&inputPage, OLD_STRING_COLUMN_NAMES, NULL, SDDS_STRING, NULL)){
case SDDS_CHECK_OKAY:
OldStringColumnsDefined=1;
break;
case SDDS_CHECK_NONEXISTENT:
break;
case SDDS_CHECK_WRONGTYPE:
case SDDS_CHECK_WRONGUNITS:
fprintf(stderr, "Something wrong with parameter OldStringColumns.\n");
exit(1);
break;
}
if (OldStringColumnsDefined){
/* decompose OldStringColumns into names of string columns for the output file */
if (!SDDS_GetParameter(&inputPage, OLD_STRING_COLUMN_NAMES, &inputStringRows))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (verbose) {
fprintf(stderr, "Parameter OldStringColumns: %s.\n", inputStringRows);
}
outputStringColumnName=(char**)malloc(sizeof(char*));
outputStringColumns=0;
buffer_size=BUFFER_SIZE_INCREMENT;
buffer=(char*)malloc(sizeof(char)*buffer_size);
while ( 0 <= (token_length = SDDS_GetToken(inputStringRows, buffer, BUFFER_SIZE_INCREMENT))){
if (!token_length)
SDDS_Bomb("A null string was detected in parameter OldStringColumns.\n");
if (!SDDS_CopyString(&outputStringColumnName[outputStringColumns], buffer))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (verbose) {
fprintf(stderr, "Output string column: %s\n", outputStringColumnName[outputStringColumns]);
}
outputStringColumns++;
}
}
}
/*********************\
* define output page *
\*********************/
if ( ipage == 1 ) {
outputRows = inputDoubleColumns;
outputDoubleColumns = inputRows;
if (inputDescription){
outputDescription = (char*) malloc( sizeof(char) * (strlen("Transpose of ") + strlen(inputDescription) + 1));
strcat(strcpy(outputDescription, "Transpose of "), inputDescription);
if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, outputDescription, inputContents, outputfile))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
else {
if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, NULL, NULL, outputfile))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (columnMajorOrder!=-1)
outputPage.layout.data_mode.column_major = columnMajorOrder;
else
outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major;
/***********************************\
* define names for double columns *
\***********************************/
if (!Root && inputStringColumns ) {
/* use specified string column, or first string column encountered */
if (!newColumnNamesColumn)
/* first string column encountered */
outputDoubleColumnName = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[0]);
else {
/* use specified string column */
if (SDDS_CheckColumn(&inputPage, newColumnNamesColumn, NULL, SDDS_STRING, stderr)!=SDDS_CHECK_OKAY)
SDDS_Bomb("column named with -newColumnNames does not exist in input");
outputDoubleColumnName = (char**)SDDS_GetColumn(&inputPage, newColumnNamesColumn);
}
for (i=1; i<inputRows; i++) {
if (match_string(outputDoubleColumnName[i-1], outputDoubleColumnName+i, inputRows-i, EXACT_MATCH)>=0) {
fprintf(stderr, "Error, duplicate %s found in input file string column %s, can not be used as output column names\n", outputDoubleColumnName[i-1], newColumnNamesColumn ? newColumnNamesColumn : inputStringColumnName[0]);
exit(1);
}
}
}
else {
/* use command line options to produce column names in the output file */
outputDoubleColumnName = (char**) malloc( outputDoubleColumns * sizeof(char*) );
digits = MAX(digits, log10(inputRows) + 1);
if (!Root){
Root = (char*) malloc( sizeof(char) * (strlen("Column")+1) );
strcpy(Root, "Column");
}
if (outputDoubleColumns!=1) {
for ( i=0; i < outputDoubleColumns; i++){
outputDoubleColumnName[i] = (char*) malloc( sizeof(char) * (strlen(Root)+digits+1));
sprintf(format, "%s%%0%ldld", Root, digits);
sprintf(outputDoubleColumnName[i], format, i);
}
}
else {/* only one row to transpose */
outputDoubleColumnName[0] = (char*) malloc( sizeof(char) * (strlen(Root)+1));
strcpy( outputDoubleColumnName[0], Root);
}
}
/*************************\
* define string columns *
\*************************/
if (OldStringColumnsDefined) {
if (!SDDS_DefineSimpleColumns(&outputPage, outputStringColumns,
outputStringColumnName, NULL, SDDS_STRING))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
else {
/* by default there should be at least one string column, that of the old column names. */
if (!noOldColumnNamesColumn) {
outputStringColumns = 1;
outputStringColumnName = (char**) malloc( sizeof(char*));
if (oldColumnNames) {
/* commanline option specification */
outputStringColumnName[0] = oldColumnNames;
}
else {
outputStringColumnName[0] = (char*) malloc( sizeof(char) * (strlen("OldColumnNames") + 1));
strcpy(outputStringColumnName[0], "OldColumnNames");
}
if ( 0 > SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
if (indexColumn && !SDDS_DefineSimpleColumn(&outputPage, "Index", NULL, SDDS_LONG))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
/*************************\
* define double columns *
\*************************/
for ( i=0; i < outputDoubleColumns; i++)
if (Symbol){
if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], Symbol, NULL, NULL,
NULL, SDDS_DOUBLE, 0))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
else {
if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL,
NULL, SDDS_DOUBLE, 0))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
/********************************\
* define string parameters *
* i.e. transposed string columns *
\********************************/
if ( inputStringColumns>1 ) {
if (0>SDDS_DefineParameter(&outputPage, OLD_STRING_COLUMN_NAMES,
NULL, NULL, "Transposed string columns", NULL, SDDS_STRING,
NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for ( i=0; i < inputStringColumns; i++){
if (0>SDDS_DefineParameter(&outputPage, inputStringColumnName[i], NULL, NULL, "Transposed string column data", NULL,
SDDS_STRING, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
/*************************\
* transfer parameters not *
* associated with old *
* string columns *
\*************************/
if (inputParameters) {
for ( i=0; i < inputParameters; i++) {
if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) &&
strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES)))
if ( 0 > SDDS_TransferParameterDefinition(&outputPage, &inputPage, inputParameterName[i], NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
/***************\
* write layout *
\***************/
SDDS_DeferSavingLayout(0);
/* if InputFile is not already transfered ot the output file, then create it. */
switch( SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL) ) {
case SDDS_CHECK_NONEXISTENT:
if (0>SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
break;
default:
break;
}
if (!SDDS_WriteLayout(&outputPage) )
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
#if defined(DEBUG)
fprintf(stderr, "table layout defined\n");
#endif
if (!SDDS_StartTable(&outputPage, outputRows) )
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (ipage == 1) {
if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
"InputFile", inputfile?inputfile:"pipe", NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
/***************************************\
* assign string columns from input *
* to string parameters in output *
\**************************************/
if ( inputStringColumns > 1) {
for ( i=0; i < inputStringColumns; i++){
columnOfStrings = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[i]);
stringParameter = JoinStrings(columnOfStrings, inputRows, BUFFER_SIZE_INCREMENT);
if ( !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
inputStringColumnName[i], stringParameter, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
free(columnOfStrings);
free(stringParameter);
}
outputStringRows = JoinStrings(inputStringColumnName, inputStringColumns, BUFFER_SIZE_INCREMENT);
if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE,
OLD_STRING_COLUMN_NAMES, outputStringRows, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
#if defined(DEBUG)
fprintf(stderr, "string parameters assigned\n");
#endif
if (inputParameters){
for ( i=0; i < inputParameters; i++){
if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) &&
strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) {
parameterPointer = (void*) SDDS_GetParameter(&inputPage, inputParameterName[i], NULL);
if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE,
inputParameterName[i], parameterPointer, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
free(parameterPointer);
}
}
}
#if defined(DEBUG)
fprintf(stderr, "input parameters assigned\n");
#endif
/**********************************\
* assign data to *
* output table part of data set *
\**********************************/
if (outputRows) {
/***************************\
* assign string column data *
\***************************/
if (OldStringColumnsDefined){
for ( i=0 ; i < outputStringColumns; i++){
if (!SDDS_GetParameter(&inputPage, outputStringColumnName[i], &stringParameter))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
stringArray=TokenizeString(stringParameter, outputRows);
if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE,
stringArray, outputRows, outputStringColumnName[i]))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
}
else {
if (!noOldColumnNamesColumn && !SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE,
inputDoubleColumnName, outputRows, outputStringColumnName[0]))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
#if defined(DEBUG)
fprintf(stderr, "string data columns assigned\n");
#endif
/***************************\
* assign double column data *
\***************************/
for ( i=0 ; i < outputDoubleColumns; i++) /* i is the row index */
if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE,
RInv->a[i], outputRows, outputDoubleColumnName[i]))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (indexColumn) {
for (i=0; i<outputRows; i++)
if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i, "Index", i, NULL))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
#if defined(DEBUG)
fprintf(stderr, "double data columns assigned\n");
#endif
}
#if defined(DEBUG)
fprintf(stderr, "data assigned\n");
#endif
if (!SDDS_WriteTable(&outputPage))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
#if defined(DEBUG)
fprintf(stderr, "data written out\n");
#endif
}
if (inputDoubleColumns) {
m_free(&RInv);
m_free(&R);
}
if (inputColumnName) {
SDDS_FreeStringArray(inputColumnName, inputColumns);
free(inputColumnName);
}
if (inputStringColumns)
free(inputStringColumnName);
if (inputDescription)
free(inputDescription);
if (inputParameterName) {
SDDS_FreeStringArray(inputParameterName, inputParameters);
free(inputParameterName);
}
if (outputDoubleColumns) {
SDDS_FreeStringArray(outputDoubleColumnName, outputDoubleColumns);
free(outputDoubleColumnName);
}
if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage))
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile))
exit(1);
return(0);
}
int32_t SDDS_AppendLayout(SDDS_DATASET *SDDS_target, SDDS_DATASET *SDDS_source, uint32_t mode)
{
SDDS_LAYOUT *source;
int32_t i;
if (!SDDS_CheckDataset(SDDS_target, "SDDS_AppendLayout"))
return(0);
if (!SDDS_CheckDataset(SDDS_source, "SDDS_AppendLayout"))
return(0);
source = &SDDS_source->layout;
SDDS_DeferSavingLayout(1);
for (i=0; i<source->n_columns; i++)
if (SDDS_GetColumnIndex(SDDS_target, source->column_definition[i].name)<0 &&
SDDS_DefineColumn(SDDS_target, source->column_definition[i].name,
source->column_definition[i].symbol,
source->column_definition[i].units, source->column_definition[i].description,
source->column_definition[i].format_string, source->column_definition[i].type,
source->column_definition[i].field_length)<0) {
SDDS_DeferSavingLayout(0);
SDDS_SetError("Unable to define column (SDDS_AppendLayout)");
return(0);
}
for (i=0; i<source->n_parameters; i++)
if (SDDS_GetParameterIndex(SDDS_target, source->parameter_definition[i].name)<0 &&
SDDS_DefineParameter(SDDS_target, source->parameter_definition[i].name,
source->parameter_definition[i].symbol,
source->parameter_definition[i].units,
source->parameter_definition[i].description,
source->parameter_definition[i].format_string,
source->parameter_definition[i].type,
source->parameter_definition[i].fixed_value)<0) {
SDDS_DeferSavingLayout(0);
SDDS_SetError("Unable to define parameter (SDDS_AppendLayout)");
return(0);
}
for (i=0; i<source->n_associates; i++)
if (SDDS_GetAssociateIndex(SDDS_target,source->associate_definition[i].name)<0 &&
SDDS_DefineAssociate(SDDS_target, source->associate_definition[i].name,
source->associate_definition[i].filename,
source->associate_definition[i].path,
source->associate_definition[i].description,
source->associate_definition[i].contents,
source->associate_definition[i].sdds)<0) {
SDDS_DeferSavingLayout(0);
SDDS_SetError("Unable to define associate (SDDS_AppendLayout)");
return(0);
}
for (i=0; i<source->n_arrays; i++)
if (SDDS_GetArrayIndex(SDDS_target, source->array_definition[i].name)<0 &&
SDDS_DefineArray(SDDS_target, source->array_definition[i].name,
source->array_definition[i].symbol,
source->array_definition[i].units, source->array_definition[i].description,
source->array_definition[i].format_string, source->array_definition[i].type,
source->array_definition[i].field_length,
source->array_definition[i].dimensions,
source->array_definition[i].group_name)<0) {
SDDS_DeferSavingLayout(0);
SDDS_SetError("Unable to define array (SDDS_AppendLayout)");
return(0);
}
SDDS_DeferSavingLayout(0);
if (!SDDS_SaveLayout(SDDS_target)) {
SDDS_SetError("Unable to save layout (SDDS_AppendLayout)");
return(0);
}
return(1);
}
