// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* // ** Copyright UCAR (c) 1992 - 2017 // ** University Corporation for Atmospheric Research(UCAR) // ** National Center for Atmospheric Research(NCAR) // ** Boulder, Colorado, USA // *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* //////////////////////////////////////////// // ParamsProjection.cc // // TDRP C++ code file for class 'ParamsProjection'. // // 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 * */ using namespace std; #include "ParamsProjection.hh" #include //////////////////////////////////////////// // Default constructor // ParamsProjection::ParamsProjection() { // zero out table memset(_table, 0, sizeof(_table)); // zero out members memset(&_start_, 0, &_end_ - &_start_); // class name _className = "ParamsProjection"; // initialize table _init(); // set members tdrpTable2User(_table, &_start_); _exitDeferred = false; } //////////////////////////////////////////// // Copy constructor // ParamsProjection::ParamsProjection(const ParamsProjection& 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 = "ParamsProjection"; // copy table tdrpCopyTable((TDRPtable *) source._table, _table); // set members tdrpTable2User(_table, &_start_); _exitDeferred = false; } //////////////////////////////////////////// // Destructor // ParamsProjection::~ParamsProjection() { // free up freeAll(); } //////////////////////////////////////////// // Assignment // void ParamsProjection::operator=(const ParamsProjection& 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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::isArgValid(const char *arg) { return (tdrpIsArgValid(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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::checkAllSet(FILE *out) { return (tdrpCheckAllSet(out, _table, &_start_)); } ////////////////////////////////////////////////////////////// // checkIsSet() // // Return TRUE if parameter is set, FALSE if not. // // int ParamsProjection::checkIsSet(const char *paramName) { return (tdrpCheckIsSet(paramName, _table, &_start_)); } //////////////////////////////////////////// // freeAll() // // Frees up all TDRP dynamic memory. // void ParamsProjection::freeAll(void) { tdrpFreeAll(_table, &_start_); } //////////////////////////////////////////// // usage() // // Prints out usage message for TDRP args as passed // in to loadFromArgs(). // void ParamsProjection::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 ParamsProjection::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 ParamsProjection::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 ParamsProjection::_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("Projection Parms"); tt->comment_text = tdrpStrDup("--------Params that give the projection---------------------"); tt++; // Parameter 'projection' // ctype is '_remap_t' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = ENUM_TYPE; tt->param_name = tdrpStrDup("projection"); tt->descr = tdrpStrDup("type of projection"); tt->help = tdrpStrDup(""); tt->val_offset = (char *) &projection - &_start_; tt->enum_def.name = tdrpStrDup("remap_t"); tt->enum_def.nfields = 4; tt->enum_def.fields = (enum_field_t *) tdrpMalloc(tt->enum_def.nfields * sizeof(enum_field_t)); tt->enum_def.fields[0].name = tdrpStrDup("REMAP_FLAT"); tt->enum_def.fields[0].val = REMAP_FLAT; tt->enum_def.fields[1].name = tdrpStrDup("REMAP_LATLON"); tt->enum_def.fields[1].val = REMAP_LATLON; tt->enum_def.fields[2].name = tdrpStrDup("REMAP_LAMBERT_CONFORMAL2"); tt->enum_def.fields[2].val = REMAP_LAMBERT_CONFORMAL2; tt->enum_def.fields[3].name = tdrpStrDup("REMAP_LAMBERT_AZIM_EQUAL_AREA"); tt->enum_def.fields[3].val = REMAP_LAMBERT_AZIM_EQUAL_AREA; tt->single_val.e = REMAP_LAMBERT_CONFORMAL2; tt++; // Parameter 'nx' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("nx"); tt->descr = tdrpStrDup("nx"); tt->help = tdrpStrDup("grid nx"); tt->val_offset = (char *) &nx - &_start_; tt->single_val.i = 0; tt++; // Parameter 'ny' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("ny"); tt->descr = tdrpStrDup("ny"); tt->help = tdrpStrDup("grid ny"); tt->val_offset = (char *) &ny - &_start_; tt->single_val.i = 0; tt++; // Parameter 'nz' // ctype is 'int' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = INT_TYPE; tt->param_name = tdrpStrDup("nz"); tt->descr = tdrpStrDup("nz"); tt->help = tdrpStrDup("grid nz"); tt->val_offset = (char *) &nz - &_start_; tt->single_val.i = 1; tt++; // Parameter 'dx' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("dx"); tt->descr = tdrpStrDup("dx"); tt->help = tdrpStrDup("grid dx "); tt->val_offset = (char *) &dx - &_start_; tt->single_val.d = 0; tt++; // Parameter 'dy' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("dy"); tt->descr = tdrpStrDup("dy"); tt->help = tdrpStrDup("grid dy "); tt->val_offset = (char *) &dy - &_start_; tt->single_val.d = 0; tt++; // Parameter 'dz' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("dz"); tt->descr = tdrpStrDup("dz"); tt->help = tdrpStrDup("grid dz "); tt->val_offset = (char *) &dz - &_start_; tt->single_val.d = 0; tt++; // Parameter 'x0' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("x0"); tt->descr = tdrpStrDup("x0"); tt->help = tdrpStrDup("grid minimum x "); tt->val_offset = (char *) &x0 - &_start_; tt->single_val.d = 0; tt++; // Parameter 'y0' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("y0"); tt->descr = tdrpStrDup("y0"); tt->help = tdrpStrDup("grid minimum y "); tt->val_offset = (char *) &y0 - &_start_; tt->single_val.d = 0; tt++; // Parameter 'z0' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("z0"); tt->descr = tdrpStrDup("z0"); tt->help = tdrpStrDup("grid minimum z"); tt->val_offset = (char *) &z0 - &_start_; tt->single_val.d = 0; tt++; // Parameter 'origin_lat' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("origin_lat"); tt->descr = tdrpStrDup("origin_lat"); tt->help = tdrpStrDup("latitude of origin"); tt->val_offset = (char *) &origin_lat - &_start_; tt->single_val.d = 0; tt++; // Parameter 'origin_lon' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("origin_lon"); tt->descr = tdrpStrDup("origin_longitude"); tt->help = tdrpStrDup("longitude of origin"); tt->val_offset = (char *) &origin_lon - &_start_; tt->single_val.d = 0; tt++; // Parameter 'offset_origin_lat' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("offset_origin_lat"); tt->descr = tdrpStrDup("offset_origin_lat"); tt->help = tdrpStrDup("latitude of offset origin"); tt->val_offset = (char *) &offset_origin_lat - &_start_; tt->single_val.d = 0; tt++; // Parameter 'offset_origin_lon' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("offset_origin_lon"); tt->descr = tdrpStrDup("offset_origin_longitude"); tt->help = tdrpStrDup("longitude of offset origin"); tt->val_offset = (char *) &offset_origin_lon - &_start_; tt->single_val.d = 0; tt++; // Parameter 'rotation' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("rotation"); tt->descr = tdrpStrDup("rotation"); tt->help = tdrpStrDup("degrees"); tt->val_offset = (char *) &rotation - &_start_; tt->single_val.d = 0; tt++; // Parameter 'lat1' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("lat1"); tt->descr = tdrpStrDup("lat1"); tt->help = tdrpStrDup("lambert conformal lat1 value"); tt->val_offset = (char *) &lat1 - &_start_; tt->single_val.d = 0; tt++; // Parameter 'lat2' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("lat2"); tt->descr = tdrpStrDup("lat2"); tt->help = tdrpStrDup("lambert conformal lat2 value"); tt->val_offset = (char *) &lat2 - &_start_; tt->single_val.d = 0; tt++; // Parameter 'earth_radius_km' // ctype is 'double' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = DOUBLE_TYPE; tt->param_name = tdrpStrDup("earth_radius_km"); tt->descr = tdrpStrDup("earth radius km"); tt->help = tdrpStrDup("Radius of the earth, kilometers"); tt->val_offset = (char *) &earth_radius_km - &_start_; tt->single_val.d = 6371.2; tt++; // Parameter 'Comment 1' memset(tt, 0, sizeof(TDRPtable)); tt->ptype = COMMENT_TYPE; tt->param_name = tdrpStrDup("Comment 1"); tt->comment_hdr = tdrpStrDup("End of Projection Params"); tt->comment_text = tdrpStrDup(""); tt++; // trailing entry has param_name set to NULL tt->param_name = NULL; return; }