/* *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* */
/* ** Copyright UCAR */
/* ** University Corporation for Atmospheric Research (UCAR) */
/* ** National Center for Atmospheric Research (NCAR) */
/* ** Boulder, Colorado, USA */
/* ** BSD licence applies - redistribution and use in source and binary */
/* ** forms, with or without modification, are permitted provided that */
/* ** the following conditions are met: */
/* ** 1) If the software is modified to produce derivative works, */
/* ** such modified software should be clearly marked, so as not */
/* ** to confuse it with the version available from UCAR. */
/* ** 2) Redistributions of source code must retain the above copyright */
/* ** notice, this list of conditions and the following disclaimer. */
/* ** 3) Redistributions in binary form must reproduce the above copyright */
/* ** notice, this list of conditions and the following disclaimer in the */
/* ** documentation and/or other materials provided with the distribution. */
/* ** 4) Neither the name of UCAR nor the names of its contributors, */
/* ** if any, may be used to endorse or promote products derived from */
/* ** this software without specific prior written permission. */
/* ** DISCLAIMER: THIS SOFTWARE IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESS */
/* ** OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/* ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
/* *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* */
////////////////////////////////////////////
// Params.cc
//
// TDRP C++ code file for class 'Params'.
//
// Code for program ObarCompute
//
// This file has been automatically
// generated by TDRP, do not modify.
//
/////////////////////////////////////////////
/**
*
* @file Params.cc
*
* @class Params
*
* This class is automatically generated by the Table
* Driven Runtime Parameters (TDRP) system
*
* @note Source is automatically generated from
* paramdef file at compile time, do not modify
* since modifications will be overwritten.
*
*
* @author Automatically generated
*
*/
#include "Params.hh"
#include <cstring>
////////////////////////////////////////////
// Default constructor
//
Params::Params()
{
// zero out table
memset(_table, 0, sizeof(_table));
// zero out members
memset(&_start_, 0, &_end_ - &_start_);
// class name
_className = "Params";
// initialize table
_init();
// set members
tdrpTable2User(_table, &_start_);
_exitDeferred = false;
}
////////////////////////////////////////////
// Copy constructor
//
Params::Params(const Params& source)
{
// sync the source object
source.sync();
// zero out table
memset(_table, 0, sizeof(_table));
// zero out members
memset(&_start_, 0, &_end_ - &_start_);
// class name
_className = "Params";
// copy table
tdrpCopyTable((TDRPtable *) source._table, _table);
// set members
tdrpTable2User(_table, &_start_);
_exitDeferred = false;
}
////////////////////////////////////////////
// Destructor
//
Params::~Params()
{
// free up
freeAll();
}
////////////////////////////////////////////
// Assignment
//
void Params::operator=(const Params& other)
{
// sync the other object
other.sync();
// free up any existing memory
freeAll();
// zero out table
memset(_table, 0, sizeof(_table));
// zero out members
memset(&_start_, 0, &_end_ - &_start_);
// copy table
tdrpCopyTable((TDRPtable *) other._table, _table);
// set members
tdrpTable2User(_table, &_start_);
_exitDeferred = other._exitDeferred;
}
////////////////////////////////////////////
// loadFromArgs()
//
// Loads up TDRP using the command line args.
//
// Check usage() for command line actions associated with
// this function.
//
// argc, argv: command line args
//
// char **override_list: A null-terminated list of overrides
// to the parameter file.
// An override string has exactly the format of an entry
// in the parameter file itself.
//
// char **params_path_p:
// If this is non-NULL, it is set to point to the path
// of the params file used.
//
// bool defer_exit: normally, if the command args contain a
// print or check request, this function will call exit().
// If defer_exit is set, such an exit is deferred and the
// private member _exitDeferred is set.
// Use exidDeferred() to test this flag.
//
// Returns 0 on success, -1 on failure.
//
int Params::loadFromArgs(int argc, char **argv,
char **override_list,
char **params_path_p,
bool defer_exit)
{
int exit_deferred;
if (_tdrpLoadFromArgs(argc, argv,
_table, &_start_,
override_list, params_path_p,
_className,
defer_exit, &exit_deferred)) {
return (-1);
} else {
if (exit_deferred) {
_exitDeferred = true;
}
return (0);
}
}
////////////////////////////////////////////
// loadApplyArgs()
//
// Loads up TDRP using the params path passed in, and applies
// the command line args for printing and checking.
//
// Check usage() for command line actions associated with
// this function.
//
// const char *param_file_path: the parameter file to be read in
//
// argc, argv: command line args
//
// char **override_list: A null-terminated list of overrides
// to the parameter file.
// An override string has exactly the format of an entry
// in the parameter file itself.
//
// bool defer_exit: normally, if the command args contain a
// print or check request, this function will call exit().
// If defer_exit is set, such an exit is deferred and the
// private member _exitDeferred is set.
// Use exidDeferred() to test this flag.
//
// Returns 0 on success, -1 on failure.
//
int Params::loadApplyArgs(const char *params_path,
int argc, char **argv,
char **override_list,
bool defer_exit)
{
int exit_deferred;
if (tdrpLoadApplyArgs(params_path, argc, argv,
_table, &_start_,
override_list,
_className,
defer_exit, &exit_deferred)) {
return (-1);
} else {
if (exit_deferred) {
_exitDeferred = true;
}
return (0);
}
}
////////////////////////////////////////////
// isArgValid()
//
// Check if a command line arg is a valid TDRP arg.
//
bool Params::isArgValid(const char *arg)
{
return (tdrpIsArgValid(arg));
}
////////////////////////////////////////////
// isArgValid()
//
// Check if a command line arg is a valid TDRP arg.
// return number of args consumed.
//
int Params::isArgValidN(const char *arg)
{
return (tdrpIsArgValidN(arg));
}
////////////////////////////////////////////
// load()
//
// Loads up TDRP for a given class.
//
// This version of load gives the programmer the option to load
// up more than one class for a single application. It is a
// lower-level routine than loadFromArgs, and hence more
// flexible, but the programmer must do more work.
//
// const char *param_file_path: the parameter file to be read in.
//
// char **override_list: A null-terminated list of overrides
// to the parameter file.
// An override string has exactly the format of an entry
// in the parameter file itself.
//
// expand_env: flag to control environment variable
// expansion during tokenization.
// If TRUE, environment expansion is set on.
// If FALSE, environment expansion is set off.
//
// Returns 0 on success, -1 on failure.
//
int Params::load(const char *param_file_path,
char **override_list,
int expand_env, int debug)
{
if (tdrpLoad(param_file_path,
_table, &_start_,
override_list,
expand_env, debug)) {
return (-1);
} else {
return (0);
}
}
////////////////////////////////////////////
// loadFromBuf()
//
// Loads up TDRP for a given class.
//
// This version of load gives the programmer the option to
// load up more than one module for a single application,
// using buffers which have been read from a specified source.
//
// const char *param_source_str: a string which describes the
// source of the parameter information. It is used for
// error reporting only.
//
// char **override_list: A null-terminated list of overrides
// to the parameter file.
// An override string has exactly the format of an entry
// in the parameter file itself.
//
// const char *inbuf: the input buffer
//
// int inlen: length of the input buffer
//
// int start_line_num: the line number in the source which
// corresponds to the start of the buffer.
//
// expand_env: flag to control environment variable
// expansion during tokenization.
// If TRUE, environment expansion is set on.
// If FALSE, environment expansion is set off.
//
// Returns 0 on success, -1 on failure.
//
int Params::loadFromBuf(const char *param_source_str,
char **override_list,
const char *inbuf, int inlen,
int start_line_num,
int expand_env, int debug)
{
if (tdrpLoadFromBuf(param_source_str,
_table, &_start_,
override_list,
inbuf, inlen, start_line_num,
expand_env, debug)) {
return (-1);
} else {
return (0);
}
}
////////////////////////////////////////////
// loadDefaults()
//
// Loads up default params for a given class.
//
// See load() for more detailed info.
//
// Returns 0 on success, -1 on failure.
//
int Params::loadDefaults(int expand_env)
{
if (tdrpLoad(NULL,
_table, &_start_,
NULL, expand_env, FALSE)) {
return (-1);
} else {
return (0);
}
}
////////////////////////////////////////////
// sync()
//
// Syncs the user struct data back into the parameter table,
// in preparation for printing.
//
// This function alters the table in a consistent manner.
// Therefore it can be regarded as const.
//
void Params::sync(void) const
{
tdrpUser2Table(_table, (char *) &_start_);
}
////////////////////////////////////////////
// print()
//
// Print params file
//
// The modes supported are:
//
// PRINT_SHORT: main comments only, no help or descriptions
// structs and arrays on a single line
// PRINT_NORM: short + descriptions and help
// PRINT_LONG: norm + arrays and structs expanded
// PRINT_VERBOSE: long + private params included
//
void Params::print(FILE *out, tdrp_print_mode_t mode)
{
tdrpPrint(out, _table, _className, mode);
}
////////////////////////////////////////////
// checkAllSet()
//
// Return TRUE if all set, FALSE if not.
//
// If out is non-NULL, prints out warning messages for those
// parameters which are not set.
//
int Params::checkAllSet(FILE *out)
{
return (tdrpCheckAllSet(out, _table, &_start_));
}
//////////////////////////////////////////////////////////////
// checkIsSet()
//
// Return TRUE if parameter is set, FALSE if not.
//
//
int Params::checkIsSet(const char *paramName)
{
return (tdrpCheckIsSet(paramName, _table, &_start_));
}
////////////////////////////////////////////
// freeAll()
//
// Frees up all TDRP dynamic memory.
//
void Params::freeAll(void)
{
tdrpFreeAll(_table, &_start_);
}
////////////////////////////////////////////
// usage()
//
// Prints out usage message for TDRP args as passed
// in to loadFromArgs().
//
void Params::usage(ostream &out)
{
out << "TDRP args: [options as below]\n"
<< " [ -params/--params path ] specify params file path\n"
<< " [ -check_params/--check_params] check which params are not set\n"
<< " [ -print_params/--print_params [mode]] print parameters\n"
<< " using following modes, default mode is 'norm'\n"
<< " short: main comments only, no help or descr\n"
<< " structs and arrays on a single line\n"
<< " norm: short + descriptions and help\n"
<< " long: norm + arrays and structs expanded\n"
<< " verbose: long + private params included\n"
<< " short_expand: short with env vars expanded\n"
<< " norm_expand: norm with env vars expanded\n"
<< " long_expand: long with env vars expanded\n"
<< " verbose_expand: verbose with env vars expanded\n"
<< " [ -tdrp_debug] debugging prints for tdrp\n"
<< " [ -tdrp_usage] print this usage\n";
}
////////////////////////////////////////////
// arrayRealloc()
//
// Realloc 1D array.
//
// If size is increased, the values from the last array
// entry is copied into the new space.
//
// Returns 0 on success, -1 on error.
//
int Params::arrayRealloc(const char *param_name, int new_array_n)
{
if (tdrpArrayRealloc(_table, &_start_,
param_name, new_array_n)) {
return (-1);
} else {
return (0);
}
}
////////////////////////////////////////////
// array2DRealloc()
//
// Realloc 2D array.
//
// If size is increased, the values from the last array
// entry is copied into the new space.
//
// Returns 0 on success, -1 on error.
//
int Params::array2DRealloc(const char *param_name,
int new_array_n1,
int new_array_n2)
{
if (tdrpArray2DRealloc(_table, &_start_, param_name,
new_array_n1, new_array_n2)) {
return (-1);
} else {
return (0);
}
}
////////////////////////////////////////////
// _init()
//
// Class table initialization function.
//
//
void Params::_init()
{
TDRPtable *tt = _table;
// Parameter 'Comment 0'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = COMMENT_TYPE;
tt->param_name = tdrpStrDup("Comment 0");
tt->comment_hdr = tdrpStrDup("ObarCompute");
tt->comment_text = tdrpStrDup("");
tt++;
// Parameter 'Comment 1'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = COMMENT_TYPE;
tt->param_name = tdrpStrDup("Comment 1");
tt->comment_hdr = tdrpStrDup("Reads in obs data");
tt->comment_text = tdrpStrDup("");
tt++;
// Parameter 'tiling_param_file'
// ctype is 'char*'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = STRING_TYPE;
tt->param_name = tdrpStrDup("tiling_param_file");
tt->descr = tdrpStrDup("");
tt->help = tdrpStrDup("File with tiling paramters");
tt->val_offset = (char *) &tiling_param_file - &_start_;
tt->single_val.s = tdrpStrDup("Tiling_20deg_10overlap_0.5deg.params");
tt++;
// Parameter 'obar_spdb'
// ctype is 'char*'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = STRING_TYPE;
tt->param_name = tdrpStrDup("obar_spdb");
tt->descr = tdrpStrDup("");
tt->help = tdrpStrDup("SPDB in which to store tile based obar");
tt->val_offset = (char *) &obar_spdb - &_start_;
tt->single_val.s = tdrpStrDup("spdbp:://localhost::x");
tt++;
// Parameter 'input_field'
// ctype is 'char*'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = STRING_TYPE;
tt->param_name = tdrpStrDup("input_field");
tt->descr = tdrpStrDup("");
tt->help = tdrpStrDup("Input field name, goes into SPDB");
tt->val_offset = (char *) &input_field - &_start_;
tt->single_val.s = tdrpStrDup("APCP3Hr");
tt++;
// Parameter 'obs_threshold'
// ctype is 'double'
memset(tt, 0, sizeof(TDRPtable));
tt->ptype = DOUBLE_TYPE;
tt->param_name = tdrpStrDup("obs_threshold");
tt->descr = tdrpStrDup("");
tt->help = tdrpStrDup("Threshold for mean obs input data value");
tt->array_offset = (char *) &_obs_threshold - &_start_;
tt->array_n_offset = (char *) &obs_threshold_n - &_start_;
tt->is_array = TRUE;
tt->array_len_fixed = FALSE;
tt->array_elem_size = sizeof(double);
tt->array_n = 1;
tt->array_vals = (tdrpVal_t *)
tdrpMalloc(tt->array_n * sizeof(tdrpVal_t));
tt->array_vals[0].d = 0;
tt++;
// trailing entry has param_name set to NULL
tt->param_name = NULL;
return;
}