ParseOptions Class Reference

#include <ParseOptions.h>

Classes
class	DataElement

Public Member Functions
	ParseOptions (void)
	~ParseOptions (void)
int	require (const char *newname, const char *parent, const char *msg, BigReal *ptr, BigReal defalt)
int	require (const char *newname, const char *parent, const char *msg, BigReal *ptr)
int	require (const char *newname, const char *parent, const char *msg, Vector *ptr, Vector defalt)
int	require (const char *newname, const char *parent, const char *msg, Vector *ptr)
int	require (const char *newname, const char *parent, const char *msg, int *ptr, int defalt)
int	require (const char *newname, const char *parent, const char *msg, int *ptr)
int	require (const char *newname, const char *parent, const char *msg, unsigned int *ptr, unsigned int defalt)
int	require (const char *newname, const char *parent, const char *msg, unsigned int *ptr)
int	requireB (const char *newname, const char *parent, const char *msg, int *ptr, int defalt)
int	requireB (const char *newname, const char *parent, const char *msg, int *ptr)
int	require (const char *newname, const char *parent, const char *msg, StringList **ptr=NULL, int many_allowed=FALSE)
int	require (const char *newname, const char *parent, const char *msg, char *ptr)
int	optional (const char *newname, const char *parent, const char *msg, BigReal *ptr, BigReal defalt)
int	optional (const char *newname, const char *parent, const char *msg, BigReal *ptr)
int	optional (const char *newname, const char *parent, const char *msg, Vector *ptr, Vector defalt)
int	optional (const char *newname, const char *parent, const char *msg, Vector *ptr)
int	optional (const char *newname, const char *parent, const char *msg, int *ptr, int defalt)
int	optional (const char *newname, const char *parent, const char *msg, int *ptr)
int	optional (const char *newname, const char *parent, const char *msg, unsigned int *ptr, unsigned int defalt)
int	optional (const char *newname, const char *parent, const char *msg, unsigned int *ptr)
int	optionalB (const char *newname, const char *parent, const char *msg, int *ptr, int defalt)
int	optionalB (const char *newname, const char *parent, const char *msg, int *ptr)
int	optional (const char *newname, const char *parent, const char *msg, StringList **ptr=NULL, int many_allowed=FALSE)
int	optional (const char *newname, const char *parent, const char *msg, char *ptr)
Range	range (const char *name)
void	range (const char *name, Range newrange)
Bool	check_consistency (void)
Bool	set (const ConfigList &configlist)
char *	getfromptr (const char *name, char *outbuf)
int	istruefromptr (const char *name)
int	issetfromptr (const char *name)
Bool	get (const char *name, int *val)
Bool	get (const char *name, BigReal *val)
Bool	get (const char *name, Vector *val)
Bool	get (const char *name, StringList **val)
Bool	get (const char *name, char *val, int n=0)
int	num (const char *name)
Bool	defined (const char *name)
Bool	exists (const char *name)
Bool	units (const char *name, Units units)
Bool	units (const char *name, Units *units)

Detailed Description

Definition at line 42 of file ParseOptions.h.

Constructor & Destructor Documentation

ParseOptions()

ParseOptions::ParseOptions

(

void

)

Definition at line 199 of file ParseOptions.C.

References TRUE, ParseOptions::DataElement::type, and ParseOptions::DataElement::UNDEF.

                               {
   configList = NULL;
   array_size = 0;
   array_max_size = 20;
   data_array = new DataElement*[array_max_size];
   DataElement *tmp = new DataElement("main", "main", TRUE,
                                      "Error in ParseOptions",
                                      (int *) NULL,  0);
   tmp->type = DataElement::UNDEF;
   add_element(tmp);
}

~ParseOptions()

ParseOptions::~ParseOptions

(

void

)

Definition at line 212 of file ParseOptions.C.

                                {
   for (int i=0; i<array_size; i++) {
      delete data_array[i];
   }
   delete [] data_array;
}

Member Function Documentation

check_consistency()

Bool ParseOptions::check_consistency

(

void

)

Definition at line 391 of file ParseOptions.C.

References endi(), FALSE, iERROR(), iout, ParseOptions::DataElement::name, ParseOptions::DataElement::parent, and TRUE.

Referenced by SimParameters::initialize_config_data().

                                         {
   int i;
   // check for lack of parent
   {
      int has_error = FALSE;
      for(i=1; i<array_size; i++) {
         if (!data_array[i]->parent_ptr) {
            // missing a parent
            iout << iERROR << "Configuration element '" << data_array[i]->name
                    << "' defined, but the parent element" << "\n" << endi;
            iout << iERROR << "  '" << data_array[i]->parent << "' is nowhere "
                    << "to be found" << "\n" << endi;
            has_error = TRUE;
         }
      }
      if (has_error) return 0;
   }

   // check for loop constructs in the "main" heirarchy
   int *arr = new int[array_size];
   for (i=0; i<array_size; i++) {  // initialize it
      arr[i] = 0;
   }
   if (!check_children(0, arr)) {
      // a loop was found
      iout << iERROR << "Loop found in ParseOptions data" << "\n" << endi;
      delete [] arr;
      return 0;
   }

   // check for elements inaccessible to "main"
   {
      int has_error = FALSE;
      for (i=1; i<array_size; i++) {
         if (arr[i] == 0) {
            // found an inaccesible element
            if (has_error == FALSE) { // first time, so print message
               iout << iERROR 
                   << "Found data in ParseOptions which are inaccessible "
                   << "to" << "\n" << endi;
               iout << iERROR 
                  << "the main data hierarchy.  Errors in:" << "\n" << endi;
               has_error = TRUE;
            }
            iout << iERROR << "   '" << data_array[i]->name << "' depends on '"
                    << data_array[i]->parent << "'" << "\n" << endi;
         }
      }
      if (has_error) {
         delete [] arr;
         return 0;
      }
   }
   // looks like everything went well
   delete [] arr;
   return 1;
}

defined()

Bool ParseOptions::defined

(

const char *

name

)

Definition at line 913 of file ParseOptions.C.

References FALSE, ParseOptions::DataElement::is_defined, and TRUE.

{
   if (!name) return FALSE;
   DataElement *tmp = internal_find(name);
   if (!tmp) return FALSE;
   if (tmp->is_defined) {
      return TRUE;
   }
   return FALSE;
}

exists()

Bool ParseOptions::exists

(

const char *

name

)

Definition at line 904 of file ParseOptions.C.

Referenced by set().

{
   if (!name) return 0;
   if (internal_find(name)) {
      return 1;
   }
   return 0;
}

get() [1/5]

Bool ParseOptions::get	(	const char *	name,
		int *	val
	)

Definition at line 998 of file ParseOptions.C.

References ParseOptions::DataElement::BOOL, StringList::data, endi(), FALSE, ParseOptions::DataElement::fdata, ParseOptions::DataElement::FLOAT, ParseOptions::DataElement::idata, iERROR(), ParseOptions::DataElement::INT, iout, ParseOptions::DataElement::is_defined, iWARN(), ParseOptions::DataElement::sldata, ParseOptions::DataElement::STRING, ParseOptions::DataElement::STRINGLIST, TRUE, ParseOptions::DataElement::type, and ParseOptions::DataElement::VECTOR.

                                                 {
   if (!val) return FALSE;
   DataElement *el = internal_find(name);
   if (el == NULL || !el->is_defined) {
      return FALSE;
   }
   switch (el->type) {
    case DataElement::FLOAT :
      iout << iWARN 
         << "ParseOptions doing a conversion from float to int for '"
         << name << "'" << "\n" << endi;
      *val = (int) el->fdata;
      return TRUE;
    case DataElement::INT:
    case DataElement::BOOL:
      *val = el->idata;
      return TRUE;
    case DataElement::STRINGLIST :
    case DataElement::STRING :
      iout << iWARN 
         << "ParseOptions doing a conversion from StringList[0] to int "
         << "for '" << name << "'" << "\n" << endi;
      *val = atoi(el->sldata->data);
      return TRUE;
    case DataElement::VECTOR :
       iout << iERROR 
          << "ParseOptions cannot convert from Vector to int for '"
          << name << "'" << "\n" << endi;
       return FALSE;
    default:
      iout << iERROR 
         << "Unknown data type " << (int)(el->type) << " for '" << name << "'"
         << "\n" << endi;
   }
   return FALSE;
}

get() [2/5]

Bool ParseOptions::get	(	const char *	name,
		BigReal *	val
	)

Definition at line 1035 of file ParseOptions.C.

References ParseOptions::DataElement::BOOL, StringList::data, endi(), FALSE, ParseOptions::DataElement::fdata, ParseOptions::DataElement::FLOAT, ParseOptions::DataElement::idata, iERROR(), ParseOptions::DataElement::INT, iout, ParseOptions::DataElement::is_defined, iWARN(), ParseOptions::DataElement::sldata, ParseOptions::DataElement::STRING, ParseOptions::DataElement::STRINGLIST, TRUE, ParseOptions::DataElement::type, and ParseOptions::DataElement::VECTOR.

                                                     {
   if (!val) return FALSE;
   DataElement *el = internal_find(name);
   if (el == NULL || !el->is_defined) {
      return FALSE;
   }
   switch (el -> type) {
    case DataElement::FLOAT: 
      *val =  el->fdata;
      return TRUE;
    case DataElement::INT:
      iout << iWARN 
         << "ParseOptions doing a conversion from int to float '"
         << name << "'" << "\n" << endi;
      *val = (BigReal) el->idata;
      return TRUE;
    case DataElement::BOOL:
      iout << iWARN 
         << "ParseOptions doing a conversion from boolean to float for '"
         << name << "'" << "\n" << endi;
      *val = (BigReal) el->idata;
      return TRUE;
    case DataElement::STRING:
    case DataElement::STRINGLIST:
     iout << iWARN 
        << "ParseOptions doing a conversion from StringList[0] to float "
        << "for '" << name << "'" << "\n" << endi;
      *val = atof(el->sldata->data);
      return TRUE;
    case DataElement::VECTOR :
       iout << iERROR 
          << "ParseOptions cannot convert from Vector to float for '"
          << name << "'" << "\n" << endi;
       return FALSE;
    default:
      iout << iERROR 
         << "Unknown data type " << (int)(el->type) << " for '" << name << "'"
         << "\n" << endi;
   }
   return FALSE;
}

get() [3/5]

Bool ParseOptions::get	(	const char *	name,
		Vector *	val
	)

Definition at line 1076 of file ParseOptions.C.

References StringList::data, endi(), FALSE, ParseOptions::DataElement::FLOAT, iERROR(), ParseOptions::DataElement::INT, iout, ParseOptions::DataElement::is_defined, iWARN(), Vector::set(), ParseOptions::DataElement::sldata, ParseOptions::DataElement::STRING, ParseOptions::DataElement::STRINGLIST, TRUE, ParseOptions::DataElement::type, ParseOptions::DataElement::vdata, and ParseOptions::DataElement::VECTOR.

                                                    {
   if (!val) return FALSE;
   DataElement *el = internal_find(name);
   if (el == NULL || !el->is_defined) {
      return FALSE;
   }
   switch (el -> type) {
    case DataElement::FLOAT:
      iout << iERROR 
         << "ParseOptions cannot convert from float to Vector for '"
         << name << "'" << "\n" << endi;
      return FALSE;
    case DataElement::INT:
      iout << iERROR 
         << "ParseOptions cannot convert from int to Vector for '"
         << name << "'" << "\n" << endi;
      return FALSE;
    case DataElement::STRING:
    case DataElement::STRINGLIST:{
      iout << iWARN 
         << "ParseOptions doing a conversion from StringList[0] to "
         << "Vector for '" << name << "'" << "\n" << endi;
      Vector v;
      if (!v.set(el->sldata->data)) {
         iout << iERROR 
            << "Could not convert '" << el->sldata->data
            << "' to a Vector";
         return FALSE;
      }
      *val = v;
      return TRUE;
     }
     case DataElement::VECTOR : 
      *val = el->vdata;
      return TRUE;
    default:
      iout << iERROR 
         << "Unknown data type " << (int)(el->type) << " for '" << name << "'"
         << "\n" << endi;

   }
   return FALSE;
}

get() [4/5]

Bool ParseOptions::get	(	const char *	name,
		StringList **	val
	)

Definition at line 1119 of file ParseOptions.C.

References FALSE, ConfigList::find(), ParseOptions::DataElement::is_defined, and TRUE.

                                                         {
   if (!val) return FALSE;
   DataElement *el = internal_find(name); // first check it is internally valid
   if (el == NULL || !el->is_defined) {
      return FALSE;
   }
   // then simply ask the configList itself for the answer
   // (while I do keep the information internally, in sldata, why bother?
   if (!configList) { return FALSE; }
   *val = configList->find(name);
   if (!*val) { return FALSE; }  // paranoia, I know...
   return TRUE;
}

get() [5/5]

Bool ParseOptions::get	(	const char *	name,
		char *	val,
		int	n = 0
	)

Definition at line 1134 of file ParseOptions.C.

References StringList::data, FALSE, StringList::next, STRINGNULL, and TRUE.

{
   if (!val || n<0) {return FALSE;}
   StringList *tmp;
   if (!get(name, &tmp)) {val[0]=STRINGNULL; return FALSE; }
   int i=n;
   while (i>0 && tmp) { // search for the nth element
      tmp=tmp->next;
      i--;
   }
   if (tmp) {  // if it was long enough, return it
      strcpy(val, tmp->data);
      return TRUE;
   }
   val[0] = STRINGNULL;
   return FALSE;
}

getfromptr()

char * ParseOptions::getfromptr	(	const char *	name,
		char *	outbuf
	)

Definition at line 938 of file ParseOptions.C.

References ParseOptions::DataElement::BOOL, StringList::data, endi(), ParseOptions::DataElement::fdata, ParseOptions::DataElement::FLOAT, ParseOptions::DataElement::fptr, ParseOptions::DataElement::idata, iERROR(), ParseOptions::DataElement::INT, iout, ParseOptions::DataElement::iptr, NAMD_bug(), PRINT_DOUBLE, PRINT_VECTOR(), ParseOptions::DataElement::sldata, ParseOptions::DataElement::slptr, ParseOptions::DataElement::sptr, ParseOptions::DataElement::STRING, ParseOptions::DataElement::STRINGLIST, ParseOptions::DataElement::type, ParseOptions::DataElement::vdata, ParseOptions::DataElement::VECTOR, and ParseOptions::DataElement::vptr.

                                                             {
#ifdef NAMD_TCL
   if ( ! name ) NAMD_bug("ParseOptions::getfromptr called with null name");
   if ( ! outbuf ) NAMD_bug("ParseOptions::getfromptr called with null outbuf");
   DataElement *el = internal_find(name);
   if ( el == NULL ) return 0;
   switch (el->type) {
    case DataElement::FLOAT :
      if ( el->fptr ) PRINT_DOUBLE(outbuf, *(el->fptr));
      else PRINT_DOUBLE(outbuf, el->fdata);
      return outbuf;
    case DataElement::INT:
    case DataElement::BOOL:
      if ( el->iptr ) sprintf(outbuf,"%d", *(el->iptr));
      else sprintf(outbuf,"%d", el->idata);
      return outbuf;
    case DataElement::STRINGLIST :
      if ( el->slptr ) return (*(el->slptr))->data;
      else if ( el->sldata ) return el->sldata->data;
      else return 0;
    case DataElement::STRING :
      if ( el->sptr ) return el->sptr;
      else if ( el->sldata ) return el->sldata->data;
      else return 0;
    case DataElement::VECTOR :
      if ( el->vptr ) PRINT_VECTOR(outbuf, *(el->vptr));
      else PRINT_VECTOR(outbuf, el->vdata);
      return outbuf;
    default:
      iout << iERROR 
         << "Unknown data type " << (int)(el->type) << " for '" << name << "'"
         << "\n" << endi;
   }
#endif
   return 0;
}

issetfromptr()

int ParseOptions::issetfromptr

(

const char *

name

)

Definition at line 987 of file ParseOptions.C.

References ParseOptions::DataElement::is_defined, and NAMD_bug().

                                               {
   if ( ! name ) NAMD_bug("ParseOptions::getfromptr called with null name");
   DataElement *el = internal_find(name);
   if ( el == NULL ) return -1;
   return (el->is_defined ? 1 : 0);
}

istruefromptr()

int ParseOptions::istruefromptr

(

const char *

name

)

Definition at line 976 of file ParseOptions.C.

References ParseOptions::DataElement::BOOL, ParseOptions::DataElement::idata, ParseOptions::DataElement::iptr, ParseOptions::DataElement::is_defined, NAMD_bug(), and ParseOptions::DataElement::type.

                                                {
   if ( ! name ) NAMD_bug("ParseOptions::getfromptr called with null name");
   DataElement *el = internal_find(name);
   if ( el == NULL ) return -1;
   if ( el->type != DataElement::BOOL ) return -2;
   if ( el->iptr ) return ((*(el->iptr)) ? 1 : 0);
   if ( ! el->is_defined ) return -3;  // ignores defaults
   return (el->idata ? 1 : 0);
}

num()

int ParseOptions::num

(

const char *

name

)

Definition at line 1153 of file ParseOptions.C.

References ParseOptions::DataElement::many_allowed, and StringList::next.

{
   DataElement *el = internal_find(name);
   if (!el || !el ->is_defined) {
      return 0;
   }
   if (!el->many_allowed) {
      return 1;
   }
   StringList *tmp;
   if (!get(name, &tmp)) { return 0; }
   int i=0;
   while (tmp) {
      i++;
      tmp=tmp->next;
   }
   return i;
}

optional() [1/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		BigReal *	ptr,
		BigReal	defalt
	)

Referenced by ParseOptions::DataElement::DataElement().

optional() [2/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		BigReal *	ptr
	)

optional() [3/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		Vector *	ptr,
		Vector	defalt
	)

optional() [4/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		Vector *	ptr
	)

optional() [5/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr,
		int	defalt
	)

optional() [6/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr
	)

optional() [7/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		unsigned int *	ptr,
		unsigned int	defalt
	)

optional() [8/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		unsigned int *	ptr
	)

optional() [9/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		StringList **	ptr = NULL,
		int	many_allowed = FALSE
	)

optional() [10/10]

int ParseOptions::optional	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		char *	ptr
	)

optionalB() [1/2]

int ParseOptions::optionalB	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr,
		int	defalt
	)

optionalB() [2/2]

int ParseOptions::optionalB	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr
	)

range() [1/2]

Range ParseOptions::range

(

const char *

name

)

Definition at line 1186 of file ParseOptions.C.

References endi(), FREE_RANGE, iERROR(), iout, and ParseOptions::DataElement::range.

{
   DataElement *el = internal_find(name);
   if (!el) {
      iout << iERROR 
         << "Trying to get the range of undefined variable '"
         << name << "'" << "\n" << endi;
      return FREE_RANGE;
   }
   return el->range;
}

range() [2/2]

void ParseOptions::range	(	const char *	name,
		Range	newrange
	)

Definition at line 1174 of file ParseOptions.C.

References endi(), iERROR(), iout, and ParseOptions::DataElement::range.

{
   DataElement *el = internal_find(name);
   if (!el) {
      iout << iERROR 
         << "Trying to set the range of undefined variable '"
         << name << "'" << "\n" << endi;
      return;
   }
   el->range = newrange;
   
}

require() [1/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		BigReal *	ptr,
		BigReal	defalt
	)

require() [2/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		BigReal *	ptr
	)

require() [3/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		Vector *	ptr,
		Vector	defalt
	)

require() [4/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		Vector *	ptr
	)

require() [5/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr,
		int	defalt
	)

require() [6/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr
	)

require() [7/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		unsigned int *	ptr,
		unsigned int	defalt
	)

require() [8/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		unsigned int *	ptr
	)

require() [9/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		StringList **	ptr = NULL,
		int	many_allowed = FALSE
	)

require() [10/10]

int ParseOptions::require	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		char *	ptr
	)

requireB() [1/2]

int ParseOptions::requireB	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr,
		int	defalt
	)

requireB() [2/2]

int ParseOptions::requireB	(	const char *	newname,
		const char *	parent,
		const char *	msg,
		int *	ptr
	)

set()

Bool ParseOptions::set

(

const ConfigList &

configlist

)

Definition at line 642 of file ParseOptions.C.

References ParseOptions::DataElement::BOOL, StringList::data, endi(), ParseOptions::DataElement::error_message, exists(), FALSE, ParseOptions::DataElement::fdata, ParseOptions::DataElement::fdef, ConfigList::find(), ParseOptions::DataElement::FLOAT, ParseOptions::DataElement::has_default, ConfigList::head(), ParseOptions::DataElement::idata, ParseOptions::DataElement::idef, iERROR(), ParseOptions::DataElement::index, ParseOptions::DataElement::INT, iout, ParseOptions::DataElement::is_defined, ParseOptions::DataElement::is_optional, iWARN(), ParseOptions::DataElement::many_allowed, ParseOptions::DataElement::name, next(), StringList::next, ParseOptions::DataElement::parent_ptr, ParseOptions::DataElement::sldata, ParseOptions::DataElement::STRING, ParseOptions::DataElement::STRINGLIST, TRUE, ParseOptions::DataElement::type, ParseOptions::DataElement::uidata, ParseOptions::DataElement::uidef, ParseOptions::DataElement::UINT, ParseOptions::DataElement::vdata, ParseOptions::DataElement::vdef, and ParseOptions::DataElement::VECTOR.

Referenced by SimParameters::initialize_config_data().

{
   // the algorithm is easy, though it looks scary
   int cont = TRUE, i;  // do some initialization
   StringList *slptr;
   DataElement *data;
   int has_error = FALSE;
   int *checked = new int[array_size];
   configList = &clist;

   // I make here a list of element I have already checked, starting
   // at the head.  I check only children of those that have already
   // been defined and add it to the checked list
   for (i=0; i<array_size; i++) 
   {
      checked[i] = FALSE;
   }

   //   make "main" 'defined' (at this point, nothing else should be defined)
   data_array[0]->is_defined = TRUE;
   checked[0] = TRUE;  // and make "main" checked
   
   // while there is still data which hasn't been defined
   while (cont) 
   {
      cont = FALSE;
      for (i=1; i<array_size; i++) 
      {  // check each element
         data = data_array[i];

         // find unchecked data which has a parent which was checked
         // and defined
         if (!checked[data->index] &&
             checked[data-> parent_ptr -> index] &&
             data -> parent_ptr -> is_defined) 
         {
            cont = TRUE;
            checked[data->index] = TRUE;  // so I don't check again

            // check to see if data is available in the StringList
            slptr = clist.find(data->name);

            if (slptr != NULL) 
            {  // it is 

               // most data types allow only 1 item, so check if that is
               // a problem.  (some StringLists, like 'parameters', allow
               // multiple strings)
               if (!data->many_allowed && slptr->next != NULL) 
               {
                  iout << iERROR << "Multiple definitions of '" << data->name << "'" << "\n" << endi;
                  iout << iERROR << "  in the configuration file are not allowed" << "\n" << endi;
                  has_error = TRUE;
               }

               data->is_defined = TRUE;

               // set the appropriate data field
               if (data->type == DataElement::FLOAT) 
               {
                  if (!scan_float(data, slptr->data)) 
                        has_error = TRUE;
               } 
               else if (data->type == DataElement::VECTOR) 
               {
                  if (!scan_vector(data, slptr->data)) 
                        has_error = TRUE;
               } 
               else if (data->type == DataElement::INT) 
               {
                  if (!scan_int(data, slptr->data)) 
                        has_error = TRUE;
               } 
               else if (data->type == DataElement::UINT) 
               {
                  if (!scan_uint(data, slptr->data)) 
                        has_error = TRUE;
               } 
               else if (data->type == DataElement::BOOL) 
               {
                  if (!scan_bool(data, slptr->data)) 
                        has_error = TRUE;
               } 
               else if (data->type == DataElement::STRINGLIST ||
                          data->type == DataElement::STRING ) 
               {
                  data->sldata = slptr;
               } 
               else 
               {
                  iout << iERROR << "Unknown ParseOption data type " << (int)(data->type) << " for "
                          << "variable " << data->name << "\n" << endi;
                  has_error = TRUE;
               }
            } 
            else 
            {  // no definition; is there a default?
               if (data->has_default) 
               {
                  data->is_defined = TRUE;

                  if (data->type == DataElement::FLOAT) 
                  {
                     data->fdata = data->fdef;
                  } 
                  else if (data->type == DataElement::VECTOR) 
                  {
                     data->vdata = data->vdef;
                  } 
                  else if (data->type == DataElement::UINT) 
                  {
                     data->uidata = data->uidef;
                  } 
                  else if (data->type == DataElement::INT ||
                             data->type == DataElement::BOOL) 
                  {
                     data->idata = data->idef;
                  } 
                  else 
                  {
                        iout << iERROR << "Unknown ParseOption data type " << (int)(data->type) << " for "
                                << "variable " << data->name << "\n" << endi;
                    has_error = TRUE;
                  }
               }
            }

            // at this point we should have gotten data from the file or the defaults,
            // or it hasn't yet been defined.  If it still isn't defined, check
            // to see if it is optional
            if (!data->is_defined) 
            { // if still not defined,
               if (!data->is_optional) 
               { // it is it required
                  has_error = TRUE;
                  iout << iERROR << "'" << data->name << "' is a required configuration option" << "\n" << endi;

                  // print some helpful information if this isn't a "main" option
                  if (data->parent_ptr != data_array[0]) 
                  {
                        iout << iERROR << "  when '" << data->parent_ptr -> name << "' is set" << "\n" << endi;
                  }  // printed parent info

                  iout << iERROR << data->name << " defines:   " << data->error_message << "\n" << endi;

               }  // printed error message
            }  
            else 
            { // there was a definition, so assign to the variable
               if (data->type ==  DataElement::FLOAT) 
               {
                  if (!set_float(data)) 
                        has_error = TRUE;
               } 
               else if ( data -> type == DataElement::VECTOR) 
               {
                  set_vector(data);
               } 
               else if ( data -> type == DataElement::INT) 
               {
                  if (!set_int(data)) 
                        has_error = TRUE;
               } 
               else if ( data -> type == DataElement::UINT) 
               {
                  if (!set_uint(data)) 
                        has_error = TRUE;
               } 
               else if ( data -> type == DataElement::BOOL) 
               {
                  set_bool(data);

                  if (is_parent_node(data)) 
                  {
                        // this makes the boolean variable undefined if it is 'off'
                        // _and_ it is a parent; this makes it agree with namd's
                        // configuration option semantics
                        data->is_defined = data->idata;
                  }
               } 
               else if ( data -> type == DataElement::STRINGLIST) 
               {
                  set_stringlist(data);
               } 
               else if ( data -> type == DataElement::STRING) 
               {
                  set_string(data);
               } 
               else 
               {
                  // already printed the error message
               }
            }
         }  // end of checking the available variables
      } // end of pass through the list
   } // end of finding data in the ConfigList


   // and now print the warning messages

   // first, find elements which are in the configuration file and are
   // valid, but which were not needed (ie, the checked array wasn''t set)
   {
      int flg = 0;

      for (int i=1; i<array_size; i++) 
      {
         if (!checked[i]) { // wasn't needed
            data = data_array[i];
            if (clist.find(data->name)) {
               if (flg == 0) {
                  flg = 1;
                  iout << iWARN 
                    << "The following variables were set in the\n";
                  iout << iWARN 
                    << "configuration file but will be ignored:\n" << endi;
               }
               iout << iWARN << "   " << data->name;
               if (data->parent_ptr != data_array[0]) {
                 iout << " (" << data->parent_ptr->name << ")";
               }
               iout << "\n" << endi;
            }
         }
      }
   }
   // and now look for names which are in the config list but which
   // are not in the parseoptions list
   {
      int flg = 0;
      ConfigList::ConfigListNode const *ptr;
      for (ptr = clist.head(); ptr != NULL; ptr = ptr -> next) {
         if (!exists(ptr -> name)) {
            if (flg == 0) {
               flg = 1;
               has_error = TRUE;
               iout << iERROR
                  << "The following variables were set in the\n";
               iout << iERROR
                  << "configuration file but are NOT VALID\n" << endi;
            }
            iout << iERROR << "   " << ptr -> name << "\n" << endi;
         }
      }
   }
      
   delete [] checked;
   return !has_error;
}

units() [1/2]

Bool ParseOptions::units	(	const char *	name,
		Units	units
	)

Definition at line 1199 of file ParseOptions.C.

References endi(), FALSE, ParseOptions::DataElement::FLOAT, iERROR(), ParseOptions::DataElement::INT, iout, N_UNIT, TRUE, and ustring().

Referenced by units().

{
  DataElement *tmp = internal_find(name);
  if (!tmp) {
     iout << iERROR 
        << name << " not found so units not set" << "\n" << endi;
     return FALSE;
  }
  if ((tmp -> type == DataElement::INT && units != N_UNIT) ||
      (tmp -> type != DataElement::INT && 
       tmp -> type != DataElement::FLOAT)) {
     iout << iERROR 
        << "Cannot set units '" << ustring(units) << "' for option '"
        << name << "'; wrong data type" << "\n" << endi;
     return FALSE;
  }
  tmp -> units = units;
  return TRUE;
}

units() [2/2]

Bool ParseOptions::units	(	const char *	name,
		Units *	units
	)

Definition at line 1219 of file ParseOptions.C.

References endi(), FALSE, ParseOptions::DataElement::FLOAT, iERROR(), ParseOptions::DataElement::INT, iout, N_UNIT, TRUE, ParseOptions::DataElement::units, and units().

{
   DataElement *tmp = internal_find(name);
   *units = N_UNIT;
   if (!tmp) {
      iout << iERROR 
         << "'" << name << "' doesn't exist so cannot get its units"
         << "\n" << endi;
      return FALSE;
   }
   if (tmp -> type != DataElement::INT && 
       tmp -> type != DataElement::FLOAT) {
      iout << iERROR 
         << "Can only get units for FLOAT and INT variables, and '"
         << name << "' isn't one of those" << "\n" << endi;
      return FALSE;
   }
   *units = tmp->units;
   return TRUE;
}

---

The documentation for this class was generated from the following files:

• ParseOptions.h
• ParseOptions.C