Teuchos - Trilinos Tools Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Teuchos_StandardParameterEntryValidators.cpp
1 // @HEADER
2 // *****************************************************************************
3 // Teuchos: Common Tools Package
4 //
5 // Copyright 2004 NTESS and the Teuchos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #include "Teuchos_StandardParameterEntryValidators.hpp"
11 #include "Teuchos_as.hpp"
12 #include <fstream>
13 
14 std::string Teuchos::getVerbosityLevelParameterValueName(
15  const EVerbosityLevel verbLevel
16  )
17 {
18  switch (verbLevel) {
19  case VERB_DEFAULT:
20  return "default";
21  case VERB_NONE:
22  return "none";
23  case VERB_LOW:
24  return "low";
25  case VERB_MEDIUM:
26  return "medium";
27  case VERB_HIGH:
28  return "high";
29  case VERB_EXTREME:
30  return "extreme";
31  default:
33  true, std::invalid_argument, "Teuchos::getVerbosityLevelParameterValue"
34  "Name(const Teuchos::EVerbosityLevel): Input argument " << verbLevel <<
35  " has an invalid value. Valid values are VERB_DEFAULT=" << VERB_DEFAULT
36  << ", VERB_NONE=" << VERB_NONE << ", VERB_LOW=" << VERB_LOW << ", "
37  "VERB_MEDIUM=" << VERB_MEDIUM << ", VERB_HIGH=" << VERB_HIGH << ", AND "
38  "VERB_EXTREME=" << VERB_EXTREME << ".");
39  }
40 
41  // NOTE (mfh 15 Sep 2014): Most compilers have figured out that the
42  // return statement below is unreachable. Some older compilers
43  // might not realize this. That's why the return statement was put
44  // there, so that those compilers don't warn that this function
45  // doesn't return a value. If it's a choice between one warning and
46  // another, I would prefer the choice that produces less code and
47  // doesn't have unreachable code (which never gets tested).
48 
49  //return ""; // Never get here!
50 }
51 
52 
55  >
56 Teuchos::verbosityLevelParameterEntryValidator(
57  std::string const& defaultParameterName
58  )
59 {
60  return rcp(
61  new StringToIntegralParameterEntryValidator<EVerbosityLevel>(
62  tuple<std::string>(
63  getVerbosityLevelParameterValueName(VERB_DEFAULT),
64  getVerbosityLevelParameterValueName(VERB_NONE),
65  getVerbosityLevelParameterValueName(VERB_LOW),
66  getVerbosityLevelParameterValueName(VERB_MEDIUM),
67  getVerbosityLevelParameterValueName(VERB_HIGH),
68  getVerbosityLevelParameterValueName(VERB_EXTREME)
69  ),
70  tuple<std::string>(
71  "Use level set in code",
72  "Produce no output",
73  "Produce minimal output",
74  "Produce a little more output",
75  "Produce a higher level of output",
76  "Produce the highest level of output"
77  ),
78  tuple<EVerbosityLevel>(
80  VERB_NONE,
81  VERB_LOW,
83  VERB_HIGH,
85  ),
86  defaultParameterName
87  )
88  );
89 }
90 
91 
92 namespace Teuchos {
93 
94 
95 //
96 // BoolParameterEntryValidator
97 //
98 
99 
100 // Constructors
101 
102 
103 BoolParameterEntryValidator::BoolParameterEntryValidator()
104 {
105  finishInitialization();
106 }
107 
108 
109 // Local non-virtual validated lookup functions
110 
111 
113  const ParameterEntry &entry, const std::string &paramName,
114  const std::string &sublistName, const bool activeQuery
115  ) const
116 {
117  const any &anyValue = entry.getAny(activeQuery);
118  if( anyValue.type() == typeid(bool) )
119  return any_cast<bool>(anyValue);
120  if( anyValue.type() == typeid(std::string) ) {
121  std::string str = any_cast<std::string>(anyValue);
122 
123  // to fix - do we want to make this customizable?
124  if( str == "false" ) {
125  return false;
126  }
127  else if( str == "true" ) {
128  return true;
129  }
130 
131  }
132  throwTypeError(entry,paramName,sublistName);
133  return 0; // Will never get here!
134 }
135 
137  ParameterList &paramList, const std::string &paramName,
138  const int defaultValue
139  ) const
140 {
141  const ParameterEntry *entry = paramList.getEntryPtr(paramName);
142  if(entry) return getBool(*entry,paramName,paramList.name(),true);
143  return paramList.get(paramName,defaultValue);
144 }
145 
146 // Overridden from ParameterEntryValidator
147 
149 {
150  return "boolValidator";
151 }
152 
154  std::string const & docString,
155  std::ostream & out
156  ) const
157 {
158  StrUtils::printLines(out,"# ",docString);
159  out << "# Accepted types: " << acceptedTypesString_ << ".\n";
160 }
161 
162 
165 {
166  return null;
167 }
168 
169 
171  ParameterEntry const& entry,
172  std::string const& paramName,
173  std::string const& sublistName
174  ) const
175 {
176  // Validate that the parameter exists and can be converted to a bool.
177  getBool(entry, paramName, sublistName, false);
178 }
179 
180 
182  std::string const& paramName,
183  std::string const& sublistName,
184  ParameterEntry * entry
185  ) const
186 {
187  TEUCHOS_TEST_FOR_EXCEPT(0==entry);
188  entry->setValue(getBool(*entry,paramName,sublistName,false), false);
189 }
190 
191 
192 // private
193 
194 
195 void BoolParameterEntryValidator::finishInitialization()
196 {
197  std::ostringstream oss;
198  oss << "\"bool\"";
199  acceptedTypesString_ = oss.str();
200  oss << "\"string\"";
201  acceptedTypesString_ = oss.str();
202 }
203 
204 
205 void BoolParameterEntryValidator::throwTypeError(
206  ParameterEntry const& entry,
207  std::string const& paramName,
208  std::string const& sublistName
209  ) const
210 {
211  const std::string &entryName = entry.getAny(false).typeName();
213  true, Exceptions::InvalidParameterType
214  ,"Error, the parameter {paramName=\""<<paramName<<"\""
215  ",type=\""<<entryName<<"\"}"
216  << "\nin the sublist \"" << sublistName << "\""
217  << "\nhas the wrong type."
218  << "\n\nThe accepted types are: " << acceptedTypesString_ << "!";
219  );
220 }
221 
222 //
223 // AnyNumberParameterEntryValidator
224 //
225 
226 
227 // Constructors
228 
229 
231  : preferredType_(PREFER_DOUBLE), acceptedTypes_(AcceptedTypes())
232 {
233  finishInitialization();
234 }
235 
236 
238  EPreferredType const preferredType, AcceptedTypes const& acceptedTypes
239  )
240  : preferredType_(preferredType), acceptedTypes_(acceptedTypes)
241 {
242  finishInitialization();
243 }
244 
245 
246 // Local non-virtual validated lookup functions
247 
248 
250  const ParameterEntry &entry, const std::string &paramName,
251  const std::string &sublistName, const bool activeQuery
252  ) const
253 {
254  const any &anyValue = entry.getAny(activeQuery);
255  if( acceptedTypes_.allowInt() && anyValue.type() == typeid(int) )
256  return any_cast<int>(anyValue);
257  if( acceptedTypes_.allowLongLong() && anyValue.type() == typeid(long long) )
258  return as<int>(any_cast<long long>(anyValue));
259  if( acceptedTypes_.allowDouble() && anyValue.type() == typeid(double) )
260  return as<int>(any_cast<double>(anyValue));
261  if( acceptedTypes_.allowString() && anyValue.type() == typeid(std::string) )
262  return convertStringToInt(any_cast<std::string>(anyValue));
263  throwTypeError(entry,paramName,sublistName);
264  return 0; // Will never get here!
265 }
266 
268  const ParameterEntry &entry, const std::string &paramName,
269  const std::string &sublistName, const bool activeQuery
270  ) const
271 {
272  const any &anyValue = entry.getAny(activeQuery);
273  if( acceptedTypes_.allowInt() && anyValue.type() == typeid(int) )
274  return as<long long>(any_cast<int>(anyValue));
275  if( acceptedTypes_.allowLongLong() && anyValue.type() == typeid(long long) )
276  return any_cast<long long>(anyValue);
277  if( acceptedTypes_.allowDouble() && anyValue.type() == typeid(double) )
278  return as<long long>(any_cast<double>(anyValue));
279  if( acceptedTypes_.allowString() && anyValue.type() == typeid(std::string) )
280  return convertStringToLongLong(any_cast<std::string>(anyValue));
281  throwTypeError(entry,paramName,sublistName);
282  return 0; // Will never get here!
283 }
284 
286  const ParameterEntry &entry, const std::string &paramName,
287  const std::string &sublistName, const bool activeQuery
288  ) const
289 {
290  const any &anyValue = entry.getAny(activeQuery);
291  if( acceptedTypes_.allowInt() && anyValue.type() == typeid(int) )
292  return as<double>(any_cast<int>(anyValue));
293  if( acceptedTypes_.allowLongLong() && anyValue.type() == typeid(long long) )
294  return as<double>(any_cast<long long>(anyValue));
295  if( acceptedTypes_.allowDouble() && anyValue.type() == typeid(double) )
296  return any_cast<double>(anyValue);
297  if( acceptedTypes_.allowString() && anyValue.type() == typeid(std::string) )
298  return convertStringToDouble(any_cast<std::string>(anyValue));
299  throwTypeError(entry,paramName,sublistName);
300  return 0.0; // Will never get here!
301 }
302 
303 
305  const ParameterEntry &entry, const std::string &paramName,
306  const std::string &sublistName, const bool activeQuery
307  ) const
308 {
309  const any &anyValue = entry.getAny(activeQuery);
310  if( acceptedTypes_.allowInt() && anyValue.type() == typeid(int) )
311  return Utils::toString(any_cast<int>(anyValue));
312  if( acceptedTypes_.allowLongLong() && anyValue.type() == typeid(long long) )
313  return Utils::toString(any_cast<long long>(anyValue));
314  if( acceptedTypes_.allowDouble() && anyValue.type() == typeid(double) )
315  return Utils::toString(any_cast<double>(anyValue));
316  if( acceptedTypes_.allowString() && anyValue.type() == typeid(std::string) )
317  return any_cast<std::string>(anyValue);
318  throwTypeError(entry,paramName,sublistName);
319  return ""; // Will never get here!
320 }
321 
322 
324  ParameterList &paramList, const std::string &paramName,
325  const int defaultValue
326  ) const
327 {
328  const ParameterEntry *entry = paramList.getEntryPtr(paramName);
329  if(entry) return getInt(*entry,paramName,paramList.name(),true);
330  return paramList.get(paramName,defaultValue);
331 }
332 
334  ParameterList &paramList, const std::string &paramName,
335  const long long defaultValue
336  ) const
337 {
338  const ParameterEntry *entry = paramList.getEntryPtr(paramName);
339  if(entry) return getLongLong(*entry,paramName,paramList.name(),true);
340  return paramList.get(paramName,defaultValue);
341 }
342 
344  ParameterList &paramList, const std::string &paramName,
345  const double defaultValue
346  ) const
347 {
348  const ParameterEntry *entry = paramList.getEntryPtr(paramName);
349  if(entry) return getDouble(*entry,paramName,paramList.name(),true);
350  return paramList.get(paramName,defaultValue);
351 }
352 
353 
355  ParameterList &paramList, const std::string &paramName,
356  const std::string &defaultValue
357  ) const
358 {
359  const ParameterEntry *entry = paramList.getEntryPtr(paramName);
360  if(entry) return getString(*entry,paramName,paramList.name(),true);
361  return paramList.get(paramName,defaultValue);
362 }
363 
365 {
366  return acceptedTypes_.allowInt();
367 }
368 
370 {
371  return acceptedTypes_.allowLongLong();
372 }
373 
375 {
376  return acceptedTypes_.allowDouble();
377 }
378 
380 {
381  return acceptedTypes_.allowString();
382 }
383 
384 
387 {
388  return preferredType_;
389 }
390 
391 
392 // Overridden from ParameterEntryValidator
393 
394 
396 {
397  return "anynumberValidator";
398 }
399 
400 
402  std::string const & docString,
403  std::ostream & out
404  ) const
405 {
406  StrUtils::printLines(out,"# ",docString);
407  out << "# Accepted types: " << acceptedTypesString_ << ".\n";
408 }
409 
410 
413 {
414  return null;
415 }
416 
417 
419  ParameterEntry const& entry,
420  std::string const& paramName,
421  std::string const& sublistName
422  ) const
423 {
424  // Validate that the parameter exists and can be converted to a double.
425  // NOTE: Even if the target type will be an 'int', we don't know that here
426  // so it will be better to assert that a 'double' can be created. The type
427  // 'double' has a very large exponent range and, subject to digit
428  // truncation, a 'double' can represent every 'int' value.
429  getDouble(entry, paramName, sublistName, false);
430 }
431 
432 
434  std::string const& paramName,
435  std::string const& sublistName,
436  ParameterEntry * entry
437  ) const
438 {
439  TEUCHOS_TEST_FOR_EXCEPT(0==entry);
440  switch(preferredType_) {
441  case PREFER_INT:
442  entry->setValue(
443  getInt(*entry,paramName,sublistName,false),
444  false // isDefault
445  );
446  break;
447  case PREFER_LONG_LONG:
448  entry->setValue(
449  getLongLong(*entry,paramName,sublistName,false),
450  false // isDefault
451  );
452  break;
453  case PREFER_DOUBLE:
454  entry->setValue(
455  getDouble(*entry,paramName,sublistName,false),
456  false // isDefault
457  );
458  break;
459  case PREFER_STRING:
460  entry->setValue(
461  getString(*entry,paramName,sublistName,false),
462  false // isDefault
463  );
464  break;
465  default:
466  TEUCHOS_TEST_FOR_EXCEPT("Error, Invalid EPreferredType value!");
467  }
468 }
469 
470 
471 // private
472 
473 
474 void AnyNumberParameterEntryValidator::finishInitialization()
475 {
476 
477  std::ostringstream oss;
478  bool addedType = false;
479  if(acceptedTypes_.allowInt()) {
480  oss << "\"int\"";
481  addedType = true;
482  }
483  if(acceptedTypes_.allowLongLong()) {
484  oss << "\"long long\"";
485  addedType = true;
486  }
487  if(acceptedTypes_.allowDouble()) {
488  if(addedType) oss << ", ";
489  oss << "\"double\"";
490  addedType = true;
491  }
492  if(acceptedTypes_.allowString()) {
493  if(addedType) oss << ", ";
494  oss << "\"string\"";
495  addedType = true;
496  }
497  acceptedTypesString_ = oss.str();
498 }
499 
500 
501 void AnyNumberParameterEntryValidator::throwTypeError(
502  ParameterEntry const& entry,
503  std::string const& paramName,
504  std::string const& sublistName
505  ) const
506 {
507  const std::string &entryName = entry.getAny(false).typeName();
509  true, Exceptions::InvalidParameterType
510  ,"Error, the parameter {paramName=\""<<paramName<<"\""
511  ",type=\""<<entryName<<"\"}"
512  << "\nin the sublist \"" << sublistName << "\""
513  << "\nhas the wrong type."
514  << "\n\nThe accepted types are: " << acceptedTypesString_ << "!";
515  );
516 }
517 
518 
519 RCP<AnyNumberParameterEntryValidator>
521 {
522  return anyNumberParameterEntryValidator(
523  AnyNumberParameterEntryValidator::PREFER_INT,
525 }
526 
527 
529  : ParameterEntryValidator(), mustAlreadyExist_(mustAlreadyExist),
530  EmptyNameOK_(false)
531 {}
532 
533 
535 {
536  return mustAlreadyExist_;
537 }
538 
540 {
541  return EmptyNameOK_;
542 }
543 
544 bool FileNameValidator::setFileMustExist(bool shouldFileExist)
545 {
546  this->mustAlreadyExist_ = shouldFileExist;
547  return mustAlreadyExist_;
548 }
549 
551 {
552  this->EmptyNameOK_ = isEmptyNameOK;
553  return EmptyNameOK_;
554 }
555 
558 {
559  return null;
560 }
561 
562 
563 void FileNameValidator::validate(ParameterEntry const &entry, std::string const &paramName,
564  std::string const &sublistName) const
565 {
566  const std::string &entryName = entry.getAny(false).typeName();
567  any anyValue = entry.getAny(true);
568  TEUCHOS_TEST_FOR_EXCEPTION(!(anyValue.type() == typeid(std::string) ),
570  "The \"" << paramName << "\"" <<
571  " parameter in the \"" << sublistName <<
572  "\" sublist is has an error." << std::endl << std::endl <<
573  "Error: The value that you entered was the wrong type." << std::endl <<
574  "Parameter: " << paramName << std::endl <<
575  "Type specified: " << entryName << std::endl <<
576  "Type accepted: " << typeid(std::string).name() <<
577  std::endl << std::endl);
578  if(mustAlreadyExist_ && !EmptyNameOK_){
579  std::string fileName = getValue<std::string>(entry);
580  TEUCHOS_TEST_FOR_EXCEPTION(!std::ifstream(fileName.c_str()),
582  "The \"" << paramName << "\"" <<
583  " parameter in the \"" << sublistName <<
584  "\" sublist is has an error." << std::endl << std::endl <<
585  "Error: The file must already exists. The value you entered does " <<
586  "not corresspond to an existing file name." << std::endl <<
587  "Parameter: " << paramName << std::endl <<
588  "File name specified: " << fileName << std::endl << std::endl);
589  }
590 }
591 
592 
593 const std::string FileNameValidator::getXMLTypeName() const
594 {
595  return "FilenameValidator";
596 }
597 
598 
600  std::string const &docString, std::ostream &out) const
601 {
602  StrUtils::printLines(out,"# ",docString);
603  out << "# Validator Used: " << std::endl;
604  out << "# FileName Validator" << std::endl;
605 }
606 
607 
609  return rcp(new FileNameValidator(true));
610 }
611 
612 
614  : ParameterEntryValidator(), validStrings_(NULL)
615 {}
616 
617 
620  validStrings_(rcp(new Array<std::string>(validStrings)))
621 {}
622 
623 
626 {
627  validStrings_ = rcp(new Array<std::string>(validStrings));
628  return validStrings_;
629 }
630 
631 
634 {
635  return validStrings_;
636 }
637 
638 
640  ParameterEntry const &entry, std::string const &paramName,
641  std::string const &sublistName) const
642 {
643  any anyValue = entry.getAny(true);
644  const std::string &entryName = entry.getAny(false).typeName();
645  TEUCHOS_TEST_FOR_EXCEPTION(!(anyValue.type() == typeid(std::string)) ,
647  "The \"" << paramName << "\"" <<
648  " parameter in the \"" << sublistName <<
649  "\" sublist is has an error." << std::endl << std::endl <<
650  "Error: The value that you entered was the wrong type." <<
651  "Parameter: " << paramName << std::endl <<
652  "Type specified: " << entryName << std::endl <<
653  "Type accepted: " << Teuchos::TypeNameTraits<std::string>::name() <<
654  std::endl);
655  if(!validStrings_.is_null()){
657  it = std::find(validStrings_->begin(),
658  validStrings_->end(), getValue<std::string>(entry));
659  TEUCHOS_TEST_FOR_EXCEPTION(it == validStrings_->end(),
661  "The \"" << paramName << "\"" <<
662  " parameter in the \"" << sublistName <<
663  "\" sublist is has an error." << std::endl << std::endl <<
664  "Error: The value that was entered doesn't fall with in "
665  "the range set by the validator." <<
666  "Parameter: " << paramName << std::endl <<
667  "Acceptable Values: " << *validStrings_ << std::endl <<
668  "Value entered: " << getValue<std::string>(entry) << std::endl <<
669  std::endl);
670  }
671 }
672 
673 
674 const std::string StringValidator::getXMLTypeName() const
675 {
676  return "StringValidator";
677 }
678 
679 
680 void StringValidator::printDoc(std::string const &docString,
681  std::ostream &out) const
682 {
683  Teuchos::StrUtils::printLines(out,"# ",docString);
684  out << "# Validator Used: " << std::endl;
685  out << "# String Validator" << std::endl;
686  if (validStrings_.get() && validStrings_->size()){
687  out << "# Acceptable Values: " << *validStrings_ << std::endl;
688  }
689 }
690 
691 
693  return rcp(new StringValidator(tuple<std::string>("")));
694 }
695 
696 
697 } // namespace Teuchos
698 
699 
700 // Nonmember helper functions
701 
703 Teuchos::boolParameterEntryValidator()
704 {
705  return rcp(new BoolParameterEntryValidator());
706 }
707 
709 Teuchos::anyNumberParameterEntryValidator()
710 {
711  return rcp(new AnyNumberParameterEntryValidator());
712 }
713 
714 
716 Teuchos::anyNumberParameterEntryValidator(
717  AnyNumberParameterEntryValidator::EPreferredType const preferredType,
718  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
719  )
720 {
721  return rcp(
722  new AnyNumberParameterEntryValidator(
723  preferredType, acceptedTypes
724  )
725  );
726 }
727 
728 void Teuchos::setIntParameter(
729  std::string const& paramName,
730  int const value, std::string const& docString,
731  ParameterList *paramList,
732  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
733  )
734 {
735  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
736  const RCP<const ParameterEntryValidator> paramEntryValidator =
738  AnyNumberParameterEntryValidator::PREFER_INT, acceptedTypes
739  );
740  paramList->set(paramName, value, docString, paramEntryValidator);
741 }
742 
743 
744 void Teuchos::setLongLongParameter(
745  std::string const& paramName,
746  long long const value, std::string const& docString,
747  ParameterList *paramList,
748  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
749  )
750 {
751  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
752  const RCP<const ParameterEntryValidator> paramEntryValidator =
754  AnyNumberParameterEntryValidator::PREFER_LONG_LONG, acceptedTypes
755  );
756  paramList->set(paramName, value, docString, paramEntryValidator);
757 }
758 
759 
760 void Teuchos::setDoubleParameter(
761  std::string const& paramName,
762  double const& value, std::string const& docString,
763  ParameterList *paramList,
764  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
765  )
766 {
767  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
768  const RCP<const ParameterEntryValidator> paramEntryValidator =
770  AnyNumberParameterEntryValidator::PREFER_DOUBLE, acceptedTypes
771  );
772  paramList->set(paramName, value, docString, paramEntryValidator);
773 }
774 
775 
776 void Teuchos::setNumericStringParameter(
777  std::string const& paramName,
778  std::string const& value, std::string const& docString,
779  ParameterList *paramList,
780  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
781  )
782 {
783  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
784  const RCP<const ParameterEntryValidator> paramEntryValidator =
786  AnyNumberParameterEntryValidator::PREFER_STRING, acceptedTypes
787  );
788  paramList->set(paramName, value, docString, paramEntryValidator);
789 }
790 
791 
792 int Teuchos::getIntParameter(
793  ParameterList const& paramList,
794  std::string const& paramName
795  )
796 {
797  const ParameterEntry &entry = paramList.getEntry(paramName);
798  RCP<const AnyNumberParameterEntryValidator>
799  anyNumValidator = rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
800  entry.validator()
801  );
802  if ( !is_null(anyNumValidator) )
803  return anyNumValidator->getInt(entry,paramName,paramList.name());
804  if ( typeid(int) == entry.getAny().type() )
805  return any_cast<int>(entry.getAny());
806  // Try the do the conversion which might fail!
807  const AnyNumberParameterEntryValidator myAnyNumValidator;
808  return myAnyNumValidator.getInt(entry,paramName,paramList.name());
809 }
810 
811 
812 long long Teuchos::getLongLongParameter(
813  ParameterList const& paramList,
814  std::string const& paramName
815  )
816 {
817  const ParameterEntry &entry = paramList.getEntry(paramName);
818  RCP<const AnyNumberParameterEntryValidator>
819  anyNumValidator = rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
820  entry.validator()
821  );
822  if ( !is_null(anyNumValidator) )
823  return anyNumValidator->getLongLong(entry,paramName,paramList.name());
824  if ( typeid(long long) == entry.getAny().type() )
825  return any_cast<long long>(entry.getAny());
826  // Try the do the conversion which might fail!
827  const AnyNumberParameterEntryValidator myAnyNumValidator;
828  return myAnyNumValidator.getLongLong(entry,paramName,paramList.name());
829 }
830 
831 
832 double Teuchos::getDoubleParameter(
833  ParameterList const& paramList,
834  std::string const& paramName
835  )
836 {
837  const ParameterEntry &entry = paramList.getEntry(paramName);
838  RCP<const AnyNumberParameterEntryValidator>
839  anyNumValidator = rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
840  entry.validator()
841  );
842  if ( !is_null(anyNumValidator) )
843  return anyNumValidator->getDouble(entry,paramName,paramList.name());
844  if ( typeid(double) == entry.getAny().type() )
845  return any_cast<double>(entry.getAny());
846  // Try the do the conversion which might fail!
847  const AnyNumberParameterEntryValidator myAnyNumValidator;
848  return myAnyNumValidator.getDouble(entry,paramName,paramList.name());
849 }
850 
851 
852 std::string Teuchos::getNumericStringParameter(
853  ParameterList const& paramList,
854  std::string const& paramName
855  )
856 {
857  const ParameterEntry &entry = paramList.getEntry(paramName);
858  RCP<const AnyNumberParameterEntryValidator>
859  anyNumValidator = rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
860  entry.validator()
861  );
862  if ( !is_null(anyNumValidator) )
863  return anyNumValidator->getString(entry,paramName,paramList.name());
864  if ( typeid(std::string) == entry.getAny().type() )
865  return any_cast<std::string>(entry.getAny());
866  // Try the do the conversion which might fail!
867  const AnyNumberParameterEntryValidator myAnyNumValidator;
868  return myAnyNumValidator.getString(entry,paramName,paramList.name());
869 }
ValidStringsList setValidStrings(const Teuchos::Array< std::string > &validStrings)
Sets the Array of valid strings and returns what the current array of valid string now is...
RCP< T > rcp(const boost::shared_ptr< T > &sptr)
Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...
void printDoc(std::string const &docString, std::ostream &out) const
const std::string & name() const
The name of this ParameterList.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
Generate output as defined by the object.
static RCP< T > getDummyObject()
Retrieves a dummy object of type T.
bool setFileMustExist(bool shouldFileExist)
Sets whether or not the validator requires the file to already exist.
void setValue(T value, bool isDefault=false, const std::string &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Templated set method that uses the input value type to determine the type of parameter.
FileNameValidator(bool mustAlreadyExist=mustAlreadyExistDefault())
Constructs a FileNameValidator.
Generate only a minimal amount of output.
RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)
Dynamic cast of underlying RCP type from T1* to T2*.
Generate no output.
EPreferredType
Determines what type is the preferred type.
T & get(const std::string &name, T def_value)
Return the parameter&#39;s value, or the default value if it is not there.
This object is held as the &quot;value&quot; in the Teuchos::ParameterList std::map.
void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
void printDoc(std::string const &docString, std::ostream &out) const
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
bool fileEmptyNameOK() const
Gets the variable describing whether or not this validator is OK with file name being empty (even if ...
Generate the most output possible.
Standard implementation of a ParameterEntryValidator that maps from a list of strings to an enum or i...
AcceptedTypes & allowString(bool _allowString)
Set allow an std::string value or not.
std::string getString(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Get a std::string value from a parameter entry.
T * get() const
Get the raw C++ pointer to the underlying object.
static std::ostream & printLines(std::ostream &os, const std::string &linePrefix, const std::string &lines)
Print lines with prefix first.
EVerbosityLevel
Verbosity level.
Modified boost::any class, which is a container for a templated value.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
bool is_null(const ArrayRCP< T > &p)
Returns true if p.get()==NULL.
AcceptedTypes & allowInt(bool _allowInt)
Set allow an int value or not.
static std::string toString(const double &x)
Write a double as a std::string.
Generate more output.
ParameterEntry * getEntryPtr(const std::string &name)
Retrieves the pointer for an entry with the name name if it exists.
EPreferredType getPreferredType() const
Lookup the preferred type.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Generate a high level of output.
double getDouble(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Get a double value from a parameter entry. will call std::stod.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
long long getLongLong(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Get a long long value from a parameter entry. will call std::stoll Note that std::stoll throws on bad...
bool setFileEmptyNameOK(bool isEmptyNameOK)
Sets whether or not the validator is OK with empty file name (even if fileMustExist() returns true) ...
A list of parameters of arbitrary type.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< AnyNumberParameterEntryValidator > anyNumberParameterEntryValidator()
Nonmember constructor AnyNumberParameterEntryValidator.
AnyNumberParameterEntryValidator()
Construct with a preferrded type of double and accept all types.
A simple validator that only allows certain string values to be choosen or simply enforces that a par...
bool getBool(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Get bool value from a parameter entry.
Abstract interface for an object that can validate a ParameterEntry&#39;s value.
any & getAny(bool activeQry=true)
Direct access to the Teuchos::any data value underlying this object. The bool argument activeQry (def...
int getInt(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Get an integer value from a parameter entry. will call std::stoi Note that std::stoi throws on badly ...
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
bool isDoubleAllowed() const
Lookup whether or not doubles are allowed.
void printDoc(std::string const &docString, std::ostream &out) const
std::string typeName() const
Return the name of the type.
AcceptedTypes & allowDouble(bool _allowDouble)
Set allow a double value or not.
bool isLongLongAllowed() const
Lookup whether or not long longs are allowed.
Smart reference counting pointer class for automatic garbage collection.
bool fileMustExist() const
Gets the variable describing whether or not this validator wants the file that is specified to alread...
const std::type_info & type() const
Return the type of value being stored.
void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
bool isStringAllowed() const
Lookup whether or not strings are allowed.
void printDoc(std::string const &docString, std::ostream &out) const
bool isIntAllowed() const
Lookup whether or not ints are allowed.
AcceptedTypes & allowLongLong(bool _allowLongLong)
Set allow an long long value or not.
Definition of Teuchos::as, for conversions between types.
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
This macro is designed to be a short version of TEUCHOS_TEST_FOR_EXCEPTION() that is easier to call...
#define TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
bool is_null() const
Returns true if the underlying pointer is null.