Teuchos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Teuchos_StandardParameterEntryValidators.hpp
Go to the documentation of this file.
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Teuchos: Common Tools Package
5 // Copyright (2004) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 #ifndef TEUCHOS_STANDARD_PARAMETER_ENTRY_VALIDATORS_H
43 #define TEUCHOS_STANDARD_PARAMETER_ENTRY_VALIDATORS_H
44 
49 #include "Teuchos_TwoDArray.hpp"
50 #include "Teuchos_Assert.hpp"
51 #include "Teuchos_StrUtils.hpp"
54 
55 #ifdef HAVE_TEUCHOSCORE_QUADMATH
56 # include <quadmath.h> // __float128 constants and functions
57 #endif // HAVE_TEUCHOSCORE_QUADMATH
58 
59 #include <locale>
60 
61 
62 namespace Teuchos {
63 
91 template<class IntegralType>
93 public:
96 
115  const std::string& defaultParameterName,
116  const bool caseSensitive = true);
117 
142  const ArrayView<const IntegralType>& integralValues,
143  std::string const& defaultParameterName,
144  const bool caseSensitive = true);
145 
176  const ArrayView<const std::string>& stringsDocs,
177  const ArrayView<const IntegralType>& integralValues,
178  const std::string& defaultParameterName,
179  const bool caseSensitive = true);
181 
183 
194  IntegralType getIntegralValue(
195  const std::string &str, const std::string &paramName = "",
196  const std::string &sublistName = ""
197  ) const;
198 
214  IntegralType
215  getIntegralValue (const ParameterEntry &entry,
216  const std::string &paramName = "",
217  const std::string &sublistName = "",
218  const bool activeQuery = true) const;
219 
235  std::string
236  getStringValue (const ParameterEntry &entry,
237  const std::string &paramName = "",
238  const std::string &sublistName = "",
239  const bool activeQuery = true) const;
240 
247  IntegralType
248  getIntegralValue (ParameterList& paramList,
249  const std::string& paramName,
250  const std::string& defaultValue) const;
251 
255  std::string getStringValue(
256  ParameterList &paramList, const std::string &paramName,
257  const std::string &defaultValue
258  ) const;
259 
266 
271  const std::string& getDefaultParameterName() const;
272 
284  std::string validateString(
285  const std::string &str, const std::string &paramName = "",
286  const std::string &sublistName = ""
287  ) const;
288 
293  bool isCaseSensitive () const {
294  return caseSensitive_;
295  }
296 
298 
300 
302  const std::string getXMLTypeName() const;
303 
305  void printDoc(
306  std::string const& docString,
307  std::ostream & out
308  ) const;
309 
312  validStringValues() const;
313 
315  void validate(
316  ParameterEntry const& entry,
317  std::string const& paramName,
318  std::string const& sublistName
319  ) const;
320 
322 
323 private:
325  std::string validValues_;
328 
329  typedef std::map<std::string,IntegralType> map_t;
331 
332  const bool caseSensitive_;
333 
334  void setValidValues(
335  ArrayView<const std::string> const& strings,
336  ArrayView<const std::string> const* stringsDocs = NULL
337  );
338 
339  // Not defined and not to be called.
341 
343  static std::string upperCase (const std::string s) {
344  std::string s_upper = s;
345  std::transform (s_upper.begin (), s_upper.end (), s_upper.begin (), ::toupper);
346  return s_upper;
347  }
348 };
349 
350 
355 template<class IntegralType>
356 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
357 stringToIntegralParameterEntryValidator(
358  ArrayView<const std::string> const& strings,
359  std::string const& defaultParameterName
360  );
361 
362 
367 template<class IntegralType>
368 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
369 stringToIntegralParameterEntryValidator(
370  ArrayView<const std::string> const& strings,
371  std::string const& defaultParameterName,
372  const bool caseSensitive
373  );
374 
375 
380 template<class IntegralType>
381 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
382 stringToIntegralParameterEntryValidator(
383  ArrayView<const std::string> const& strings,
384  ArrayView<const IntegralType> const& integralValues,
385  std::string const& defaultParameterName
386  );
387 
388 
393 template<class IntegralType>
394 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
395 stringToIntegralParameterEntryValidator(
396  ArrayView<const std::string> const& strings,
397  ArrayView<const IntegralType> const& integralValues,
398  std::string const& defaultParameterName,
399  const bool caseSensitive
400  );
401 
402 
407 template<class IntegralType>
408 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
409 stringToIntegralParameterEntryValidator(
410  ArrayView<const std::string> const& strings,
411  ArrayView<const std::string> const& stringsDocs,
412  ArrayView<const IntegralType> const& integralValues,
413  std::string const& defaultParameterName
414  );
415 
416 
421 template<class IntegralType>
422 RCP<StringToIntegralParameterEntryValidator<IntegralType> >
423 stringToIntegralParameterEntryValidator(
424  ArrayView<const std::string> const& strings,
425  ArrayView<const std::string> const& stringsDocs,
426  ArrayView<const IntegralType> const& integralValues,
427  std::string const& defaultParameterName,
428  const bool caseSensitive
429  );
430 
431 
442 template<class IntegralType>
443 void setStringToIntegralParameter(
444  std::string const& paramName,
445  std::string const& defaultValue,
446  std::string const& docString,
447  ArrayView<const std::string> const& strings,
448  ParameterList * paramList
449  );
450 
451 
463 template<class IntegralType>
464 void setStringToIntegralParameter(
465  std::string const& paramName,
466  std::string const& defaultValue,
467  std::string const& docString,
468  ArrayView<const std::string> const& strings,
469  ArrayView<const IntegralType> const& integralValues,
470  ParameterList * paramList
471  );
472 
473 
485 template<class IntegralType>
486 void setStringToIntegralParameter(
487  std::string const& paramName,
488  std::string const& defaultValue,
489  std::string const& docString,
490  ArrayView<const std::string> const& strings,
491  ArrayView<const std::string> const& stringsDocs,
492  ArrayView<const IntegralType> const& integralValues,
493  ParameterList * paramList
494  );
495 
496 
507 template<class IntegralType>
508 IntegralType getIntegralValue(
509  ParameterList const& paramList, std::string const& paramName
510  );
511 
512 
524 template<class IntegralType>
525 std::string getStringValue(
526  ParameterList const& paramList, std::string const& paramName
527  );
528 
529 
535 template<class IntegralType>
536 RCP<const StringToIntegralParameterEntryValidator<IntegralType> >
538  ParameterEntry const& entry, ParameterList const& paramList,
539  std::string const& paramName
540  );
541 
542 
548 std::string getVerbosityLevelParameterValueName(
549  const EVerbosityLevel verbLevel
550  );
551 
552 
557 RCP<StringToIntegralParameterEntryValidator<EVerbosityLevel> >
558 verbosityLevelParameterEntryValidator(std::string const& defaultParameterName);
559 
565 template<class IntegralType>
567 
568 public:
569 
572 
577  getDummyObject();
578 
580 };
581 
582 template<class IntegralType>
585 {
586  return stringToIntegralParameterEntryValidator<IntegralType>(
587  tuple<std::string>(""), tuple<std::string>(""),
588  tuple<IntegralType>((IntegralType)1), "");
589 }
590 
604  : public ParameterEntryValidator
605 {
606 public:
607 
610 
612 
614 
617 
619  bool getBool(
620  const ParameterEntry &entry, const std::string &paramName = "",
621  const std::string &sublistName = "", const bool activeQuery = true
622  ) const;
623 
627  bool getBool(
628  ParameterList &paramList, const std::string &paramName,
629  const int defaultValue
630  ) const;
631 
633 
636 
638  const std::string getXMLTypeName() const;
639 
641  void printDoc(
642  std::string const& docString,
643  std::ostream & out
644  ) const;
645 
648  validStringValues() const;
649 
651  void validate(
652  ParameterEntry const& entry,
653  std::string const& paramName,
654  std::string const& sublistName
655  ) const;
656 
658  void validateAndModify(
659  std::string const& paramName,
660  std::string const& sublistName,
661  ParameterEntry * entry
662  ) const;
663 
665 
666 private:
667 
668  // ////////////////////////////
669  // Private data members
670 
671  std::string acceptedTypesString_;
672 
673  // ////////////////////////////
674  // Private member functions
675 
676  void finishInitialization();
677 
678  void throwTypeError(
679  ParameterEntry const& entry,
680  std::string const& paramName,
681  std::string const& sublistName
682  ) const;
683 };
684 
685 // Nonmember helper functions
686 
687 
693 boolParameterEntryValidator();
694 
695 
710  : public ParameterEntryValidator
711 {
712 public:
713 
716 
718  enum EPreferredType { PREFER_INT, PREFER_LONG_LONG, PREFER_DOUBLE, PREFER_STRING };
719 
720 
723  public:
725  AcceptedTypes( bool allowAllTypesByDefault = true )
726  :allowInt_(allowAllTypesByDefault)
727  ,allowLongLong_(allowAllTypesByDefault)
728  ,allowDouble_(allowAllTypesByDefault)
729  ,allowString_(allowAllTypesByDefault)
730  {}
732  AcceptedTypes& allowInt( bool _allowInt )
733  { allowInt_ = _allowInt; return *this; }
735  AcceptedTypes& allowLongLong( bool _allowLongLong )
736  { allowLongLong_ = _allowLongLong; return *this; }
738  AcceptedTypes& allowDouble( bool _allowDouble )
739  { allowDouble_ = _allowDouble; return *this; }
741  AcceptedTypes& allowString( bool _allowString )
742  { allowString_ = _allowString; return *this; }
744  bool allowInt() const { return allowInt_; }
746  bool allowLongLong() const { return allowLongLong_; }
748  bool allowDouble() const { return allowDouble_; }
750  bool allowString() const { return allowString_; }
751  private:
752  bool allowInt_;
756  };
757 
759 
762 
767 
779  EPreferredType const preferredType,
780  AcceptedTypes const& acceptedTypes
781  );
782 
784 
787 
793  int getInt(
794  const ParameterEntry &entry, const std::string &paramName = "",
795  const std::string &sublistName = "", const bool activeQuery = true
796  ) const;
797 
803  long long getLongLong(
804  const ParameterEntry &entry, const std::string &paramName = "",
805  const std::string &sublistName = "", const bool activeQuery = true
806  ) const;
807 
811  double getDouble(
812  const ParameterEntry &entry, const std::string &paramName = "",
813  const std::string &sublistName = "", const bool activeQuery = true
814  ) const;
815 
817  std::string getString(
818  const ParameterEntry &entry, const std::string &paramName = "",
819  const std::string &sublistName = "", const bool activeQuery = true
820  ) const;
821 
825  int getInt(
826  ParameterList &paramList, const std::string &paramName,
827  const int defaultValue
828  ) const;
829 
833  long long getLongLong(
834  ParameterList &paramList, const std::string &paramName,
835  const long long defaultValue
836  ) const;
837 
841  double getDouble(
842  ParameterList &paramList, const std::string &paramName,
843  const double defaultValue
844  ) const;
845 
849  std::string getString(
850  ParameterList &paramList, const std::string &paramName,
851  const std::string &defaultValue
852  ) const;
853 
856  bool isIntAllowed() const;
857 
860  bool isLongLongAllowed() const;
861 
864  bool isDoubleAllowed() const;
865 
868  bool isStringAllowed() const;
869 
872  EPreferredType getPreferredType() const;
873 
875  static const std::string& getPrefferedTypeString (EPreferredType enumValue)
876  {
877  switch (enumValue) {
878  case PREFER_INT:
879  return getIntEnumString ();
880  case PREFER_LONG_LONG:
881  return getLongLongEnumString ();
882  case PREFER_DOUBLE:
883  return getDoubleEnumString ();
884  case PREFER_STRING:
885  return getStringEnumString ();
886  default:
887  const std::string typeString (toString (enumValue));
888  throw std::runtime_error("Cannot convert enumValue: " + typeString + " to a string");
889  }
890  }
891 
893  static EPreferredType getPrefferedTypeStringEnum (const std::string& enumString)
894  {
895  if (enumString == getIntEnumString ()) {
896  return PREFER_INT;
897  }
898  else if (enumString == getLongLongEnumString ()) {
899  return PREFER_LONG_LONG;
900  }
901  else if (enumString == getDoubleEnumString ()) {
902  return PREFER_DOUBLE;
903  }
904  else if (enumString == getStringEnumString ()) {
905  return PREFER_STRING;
906  }
907  else {
908  throw std::runtime_error ("Cannot convert enumString: " + enumString + " to an enum");
909  }
910  }
911 
913 
916 
918  const std::string getXMLTypeName() const;
919 
921  void printDoc(
922  std::string const& docString,
923  std::ostream & out
924  ) const;
925 
927  ValidStringsList
928  validStringValues() const;
929 
931  void validate(
932  ParameterEntry const& entry,
933  std::string const& paramName,
934  std::string const& sublistName
935  ) const;
936 
938  void validateAndModify(
939  std::string const& paramName,
940  std::string const& sublistName,
941  ParameterEntry * entry
942  ) const;
943 
944 
946 
947 private:
948 
949  // ////////////////////////////
950  // Private data members
951 
953  std::string acceptedTypesString_;
954 
955 //use pragmas to disable some false-positive warnings for windows sharedlibs export
956 #ifdef _MSC_VER
957 #pragma warning(push)
958 #pragma warning(disable:4251)
959 #endif
961 #ifdef _MSC_VER
962 #pragma warning(pop)
963 #endif
964 
965  // ////////////////////////////
966  // Private member functions
967 
968  /* \brief Gets the string representing the "int" preferred type enum */
969  static const std::string& getIntEnumString(){
970  static const std::string intEnumString_ = TypeNameTraits<int>::name();
971  return intEnumString_;
972  }
973 
974  /* \brief Gets the string representing the "int" preferred type enum */
975  static const std::string& getLongLongEnumString(){
976  static const std::string longLongEnumString_ = TypeNameTraits<long long>::name();
977  return longLongEnumString_;
978  }
979 
980  /* \brief Gets the string representing the "double" preferred type enum */
981  static const std::string& getDoubleEnumString(){
982  static const std::string doubleEnumString_ = TypeNameTraits<double>::name();
983  return doubleEnumString_;
984  }
985 
986  /* \brief Gets the string representing the "string" preferred type enum */
987  static const std::string& getStringEnumString(){
988  static const std::string stringEnumString_ = TypeNameTraits<std::string>::name();
989  return stringEnumString_;
990  }
991 
992 
993  void finishInitialization();
994 
995  void throwTypeError(
996  ParameterEntry const& entry,
997  std::string const& paramName,
998  std::string const& sublistName
999  ) const;
1000 
1001 };
1002 
1003 
1004 // Nonmember helper functions
1005 
1006 
1011 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<AnyNumberParameterEntryValidator>
1012 anyNumberParameterEntryValidator();
1013 
1014 
1019 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<AnyNumberParameterEntryValidator>
1020 anyNumberParameterEntryValidator(
1022  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
1023  );
1024 
1030 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setIntParameter(
1031  std::string const& paramName,
1032  int const value, std::string const& docString,
1033  ParameterList *paramList,
1034  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
1035  = AnyNumberParameterEntryValidator::AcceptedTypes()
1036  );
1037 
1038 
1044 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setLongLongParameter(
1045  std::string const& paramName,
1046  long long const value, std::string const& docString,
1047  ParameterList *paramList,
1048  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
1049  = AnyNumberParameterEntryValidator::AcceptedTypes()
1050  );
1051 
1057 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setDoubleParameter(
1058  std::string const& paramName,
1059  double const& value, std::string const& docString,
1060  ParameterList *paramList,
1061  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
1062  = AnyNumberParameterEntryValidator::AcceptedTypes()
1063  );
1064 
1065 
1071 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setNumericStringParameter(
1072  std::string const& paramName,
1073  std::string const& value, std::string const& docString,
1074  ParameterList *paramList,
1075  AnyNumberParameterEntryValidator::AcceptedTypes const& acceptedTypes
1076  = AnyNumberParameterEntryValidator::AcceptedTypes()
1077  );
1078 
1079 
1094 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT int getIntParameter(
1095  ParameterList const& paramList, std::string const& paramName
1096  );
1097 
1098 
1113 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT long long getLongLongParameter(
1114  ParameterList const& paramList, std::string const& paramName
1115  );
1116 
1131 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT double getDoubleParameter(
1132  ParameterList const& paramList,
1133  std::string const& paramName
1134  );
1135 
1136 
1152 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT std::string getNumericStringParameter(
1153  ParameterList const& paramList,
1154  std::string const& paramName
1155  );
1156 
1162 template<>
1164 
1165 public:
1166 
1169 
1173  static RCP<AnyNumberParameterEntryValidator > getDummyObject();
1174 
1176 
1177 };
1178 
1179 
1184 template <class T>
1187  static inline T notDefined() {
1188  return T::this_type_is_missing_a_specialization();
1189  }
1190 };
1191 
1192 
1213 template <class T>
1215 public:
1216 
1218  static inline T min()
1220 
1222  static inline T max()
1224 
1227  static inline T defaultStep()
1229 
1232  static inline unsigned short defaultPrecision()
1234 
1235 };
1236 
1237 
1238 template<>
1239 class EnhancedNumberTraits<short int>{
1240 public:
1241  static inline short int min() { return std::numeric_limits<short int>::min(); }
1242  static inline short int max() { return std::numeric_limits<short int>::max(); }
1243  static inline short int defaultStep() { return 1; }
1244  static inline unsigned short defaultPrecision() { return 0; }
1245 };
1246 
1247 
1248 template<>
1249 class EnhancedNumberTraits<short unsigned int>{
1250 public:
1251  static inline short unsigned int min() { return std::numeric_limits<short unsigned int>::min(); }
1252  static inline short unsigned int max() { return std::numeric_limits<short unsigned int>::max(); }
1253  static inline short unsigned int defaultStep() { return 1; }
1254  static inline unsigned short defaultPrecision() { return 0; }
1255 };
1256 
1257 
1258 template<>
1260 public:
1261  static inline int min() { return std::numeric_limits<int>::min(); }
1262  static inline int max() { return std::numeric_limits<int>::max(); }
1263  static inline int defaultStep() { return 1; }
1264  static inline unsigned short defaultPrecision() { return 0; }
1265 };
1266 
1267 
1268 template<>
1269 class EnhancedNumberTraits<unsigned int>{
1270 public:
1271  static inline unsigned int min() { return std::numeric_limits<unsigned int>::min(); }
1272  static inline unsigned int max() { return std::numeric_limits<unsigned int>::max(); }
1273  static inline unsigned int defaultStep() { return 1; }
1274  static inline unsigned short defaultPrecision() { return 0; }
1275 };
1276 
1277 
1278 template<>
1279 class EnhancedNumberTraits<long int>{
1280 public:
1281  static inline long int min() { return std::numeric_limits<long int>::min(); }
1282  static inline long int max() { return std::numeric_limits<long int>::max(); }
1283  static inline long int defaultStep() { return 1; }
1284  static inline unsigned short defaultPrecision() { return 0; }
1285 };
1286 
1287 
1288 template<>
1289 class EnhancedNumberTraits<long unsigned int>{
1290 public:
1291  static inline long unsigned int min() { return std::numeric_limits<long unsigned int>::min(); }
1292  static inline long unsigned int max() { return std::numeric_limits<long unsigned int>::max(); }
1293  static inline long unsigned int defaultStep() { return 1; }
1294  static inline unsigned short defaultPrecision() { return 0; }
1295 };
1296 
1297 
1298 template<>
1299 class EnhancedNumberTraits<long long int>{
1300 public:
1301  static inline long long int min() { return std::numeric_limits<long long int>::min(); }
1302  static inline long long int max() { return std::numeric_limits<long long int>::max(); }
1303  static inline long long int defaultStep() { return 1; }
1304  static inline unsigned short defaultPrecision() { return 0; }
1305 };
1306 
1307 
1308 template<>
1309 class EnhancedNumberTraits<long long unsigned int>{
1310 public:
1311  static inline long long unsigned int min() { return std::numeric_limits<long long unsigned int>::min(); }
1312  static inline long long unsigned int max() { return std::numeric_limits<long long unsigned int>::max(); }
1313  static inline long long unsigned int defaultStep() { return 1; }
1314  static inline unsigned short defaultPrecision() { return 0; }
1315 };
1316 
1317 
1318 #ifdef HAVE_TEUCHOSCORE_QUADMATH
1319 template<>
1320 class EnhancedNumberTraits<__float128>{
1321 public:
1322  static inline __float128 min() { return -std::numeric_limits<__float128>::max(); }
1323  static inline __float128 max() { return std::numeric_limits<__float128>::max(); }
1324  static inline __float128 defaultStep() { return 1; }
1325  static inline unsigned short defaultPrecision() { return 100; }
1326 };
1327 #endif // HAVE_TEUCHOSCORE_QUADMATH
1328 
1329 template<>
1330 class EnhancedNumberTraits<double>{
1331 public:
1332  static inline double min() { return -std::numeric_limits<double>::max(); }
1333  static inline double max() { return std::numeric_limits<double>::max(); }
1334  static inline double defaultStep() { return 1; }
1335  static inline unsigned short defaultPrecision() { return 100; }
1336 };
1337 
1338 #ifdef HAVE_TEUCHOS_LONG_DOUBLE
1339 template<>
1340 class EnhancedNumberTraits<long double>{
1341 public:
1342  static inline long double min() { return -std::numeric_limits<long double>::max(); }
1343  static inline long double max() { return std::numeric_limits<long double>::max(); }
1344  static inline long double defaultStep() { return 1; }
1345  static inline unsigned short defaultPrecision() { return 100; }
1346 };
1347 #endif
1348 
1349 template<>
1351 public:
1352  static inline float min() { return -std::numeric_limits<float>::max(); }
1353  static inline float max() { return std::numeric_limits<float>::max(); }
1354  static inline float defaultStep() { return 1; }
1355  static inline unsigned short defaultPrecision() { return 100; }
1356 };
1357 
1363 template <class T>
1365 
1366 public:
1367 
1370 
1386  T min,
1387  T max,
1389  unsigned short precision=EnhancedNumberTraits<T>::defaultPrecision()):
1391  minVal(min), maxVal(max), step_(step), precision_(precision),
1392  containsMin(true), containsMax(true){}
1393 
1399  minVal(EnhancedNumberTraits<T>::min()),
1400  maxVal(EnhancedNumberTraits<T>::max()),
1401  step_(EnhancedNumberTraits<T>::defaultStep()),
1402  precision_(EnhancedNumberTraits<T>::defaultPrecision()),
1403  containsMin(false),
1404  containsMax(false){}
1405 
1407 
1409 
1410 
1415  void setMin(T min){
1416  minVal = min;
1417  containsMin = true;
1418  }
1419 
1424  void setMax(T max){
1425  maxVal = max;
1426  containsMax = true;
1427  }
1428 
1433  void setStep(T step){
1434  step_ = step;
1435  }
1436 
1441  void setPrecision(unsigned short precision){
1442  precision_ = precision;
1443  }
1444 
1446 
1449 
1454  T getMin() const{
1455  return minVal;
1456  }
1457 
1462  T getMax() const{
1463  return maxVal;
1464  }
1465 
1470  T getStep() const{
1471  return step_;
1472  }
1473 
1478  unsigned short getPrecision() const{
1479  return precision_;
1480  }
1481 
1483 
1485 
1486 
1491  bool hasMin() const{
1492  return containsMin;
1493  }
1494 
1499  bool hasMax() const{
1500  return containsMax;
1501  }
1502 
1504 
1507 
1510  return null;
1511  }
1512 
1514  void validate(ParameterEntry const &entry, std::string const &paramName,
1515  std::string const &sublistName) const;
1516 
1518  void validateAndModify( std::string const& paramName,
1519  std::string const& sublistName, ParameterEntry * entry) const;
1520 
1523  const bool activeQuery) const;
1524 
1526  const std::string getXMLTypeName() const{
1527  return "EnhancedNumberValidator(" + TypeNameTraits<T>::name()+ ")";
1528  }
1529 
1531  void printDoc(std::string const &docString, std::ostream &out) const{
1532  StrUtils::printLines(out,"# ",docString);
1533  out << "#\tValidator Used: " << std::endl;
1534  out << "#\t\tNumber Validator" << std::endl;
1535  out << "#\t\tType: " << Teuchos::TypeNameTraits<T>::name() <<
1536  std::endl;
1537  out << "#\t\tMin (inclusive): " << minVal << std::endl;
1538  out << "#\t\tMax (inclusive): " << maxVal << std::endl;
1539  }
1540 
1542 
1543 private:
1546 
1547  // note this was discussed in issue #612
1548  // currently we are keeping a string validator with EnhancedNumberValidator
1549  // an alternative is to make a combined class for AnyNumberParameterEntryValidator
1550  // and EnhancedNumberValidator
1551  bool useIntConversions() const;
1552 
1554 
1557 
1561 
1565 
1569 
1573  unsigned short precision_;
1574 
1578 
1582 
1584 
1585 };
1586 
1587 template<class T>
1589  std::string const& paramName,
1590  std::string const& sublistName,
1591  ParameterEntry * entry
1592  ) const
1593 {
1594  TEUCHOS_TEST_FOR_EXCEPT(0==entry);
1595 
1596  any anyValue = entry->getAny(true);
1597  // preferred type is not string
1598  if( anyValue.type() == typeid(std::string) ) {
1599  anyValue = getNumberFromString(*entry,false);
1600  entry->setValue(
1601  any_cast<T>(anyValue),
1602  false // isDefault
1603  );
1604  }
1605  else {
1606  // default behavior
1608  paramName, sublistName, entry);
1609  }
1610 }
1611 
1612 template<class T>
1614 {
1615  // this will need some rethinking and exists only for supporting
1616  // conversion of strings to the templated type T
1617  // but we may want to unify this into the base class anyways
1618  // and share string conversion concepts with other parameters
1619  // like AnyNumberParameterEntryValidator
1620  if(typeid(T) == typeid(char)) return true;
1621  if(typeid(T) == typeid(unsigned char)) return true;
1622  if(typeid(T) == typeid(int)) return true;
1623  if(typeid(T) == typeid(unsigned int)) return true;
1624  if(typeid(T) == typeid(short)) return true;
1625  if(typeid(T) == typeid(unsigned short)) return true;
1626  if(typeid(T) == typeid(long)) return true;
1627  if(typeid(T) == typeid(unsigned long)) return true;
1628  if(typeid(T) == typeid(long long)) return true;
1629  if(typeid(T) == typeid(unsigned long long)) return true;
1630 
1631  // default to double stod to older atof conversion
1632  // depending on HAVE_TEUCHOSCORE_CXX11
1633  // those conversions would probably handle all above discrete types anyways
1634  return false;
1635 }
1636 
1637 template<class T>
1639  const ParameterEntry &entry, const bool activeQuery
1640  ) const
1641 {
1642  // perhaps we want to just eliminate the int checks
1643  // and always use double conversion which I think would work
1644  // well for all types - but this will give us a behavior which mirrors
1645  // AnyNumberParameterEntryValidator more closely
1646  const any &anyValue = entry.getAny(activeQuery);
1647  if(useIntConversions()) {
1648  return any((T)convertStringToInt(any_cast<std::string>(anyValue)));
1649  }
1650  else { // if not discrete, read as a double and cast to our type T
1651  return any((T)convertStringToDouble(any_cast<std::string>(anyValue)));
1652  }
1653 }
1654 
1655 template<class T>
1656 void EnhancedNumberValidator<T>::validate(ParameterEntry const &entry, std::string const &paramName,
1657  std::string const &sublistName) const
1658 {
1659  any anyValue = entry.getAny(true);
1660 
1661  // This was new code added to allow EnhancedNumberValidator to accept a string
1662  // This was added for consistency with AnyNumberParameterEntryValidator
1663  // and the new BoolParameterEntryValidator which all take string
1664  // We may wish to change this to be optional like AnyNumberParameterEntryValidator
1665  if( anyValue.type() == typeid(std::string) ) {
1666  // try to upgrade from a string to a number
1667  anyValue = getNumberFromString(entry, false);
1668  }
1669 
1670  const std::string &entryName = entry.getAny(false).typeName();
1671  TEUCHOS_TEST_FOR_EXCEPTION(anyValue.type() != typeid(T),
1673  "The \"" << paramName << "\"" <<
1674  " parameter in the \"" << sublistName <<
1675  "\" sublist is has an error." << std::endl << std::endl <<
1676  "Error: The value that you entered was the wrong type." << std::endl <<
1677  "Parameter: " << paramName << std::endl <<
1678  "Type specified: " << entryName << std::endl <<
1679  "Type accepted: " << Teuchos::TypeNameTraits<T>::name() << std::endl);
1680 
1681  bool isValueInRange;
1682  any_cast<T>(anyValue) >= minVal && any_cast<T>(anyValue) <= maxVal
1683  ? isValueInRange = true : isValueInRange=false;
1684  TEUCHOS_TEST_FOR_EXCEPTION(!(isValueInRange),
1686  "The \"" << paramName << "\"" <<
1687  " parameter in the \"" << sublistName <<
1688  "\" sublist is has an error." << std::endl << std::endl <<
1689  "Error: The value that was entered doesn't fall with in " <<
1690  "the range set by the validator" << std::endl <<
1691  "Parameter: " << paramName << std::endl <<
1692  "Min: " << minVal << std::endl <<
1693  "Max: " << maxVal << std::endl <<
1694  "Value entered: " <<
1695  (any_cast<T>(anyValue)) << std::endl << std::endl);
1696 }
1697 
1703 template<class T>
1705 
1706 public:
1707 
1710 
1715 
1717 };
1718 
1719 template<class T>
1722 {
1723  return rcp(new EnhancedNumberValidator<T>);
1724 }
1725 
1735 
1736 public:
1737 
1740 
1743  static bool mustAlreadyExistDefault() { return false; }
1744 
1746 
1749 
1755  FileNameValidator(bool mustAlreadyExist = mustAlreadyExistDefault());
1756 
1758 
1760 
1761 
1767  bool fileMustExist() const;
1768 
1770 
1771 
1782  bool fileEmptyNameOK() const;
1783 
1785 
1787 
1788 
1797  bool setFileMustExist(bool shouldFileExist);
1798 
1807  bool setFileEmptyNameOK(bool isEmptyNameOK);
1808 
1810 
1813 
1815  ValidStringsList validStringValues() const;
1816 
1818  void validate(
1819  ParameterEntry const &entry,
1820  std::string const &paramName,
1821  std::string const &sublistName) const;
1822 
1824  const std::string getXMLTypeName() const;
1825 
1827  void printDoc(std::string const &docString, std::ostream &out) const;
1828 
1830 
1831 private:
1832 
1835 
1841 
1843 
1844 };
1845 
1851 template<>
1853 
1854 public:
1855 
1858 
1862  static RCP<FileNameValidator> getDummyObject();
1863 
1865 
1866 };
1867 
1876 
1877 public:
1878 
1881 
1884  StringValidator();
1885 
1890  StringValidator(const Teuchos::Array<std::string> &validStrings);
1891 
1893 
1895 
1896 
1904  ValidStringsList setValidStrings(
1905  const Teuchos::Array<std::string> &validStrings);
1906 
1908 
1911 
1913  ValidStringsList validStringValues() const;
1914 
1916  void validate(ParameterEntry const &entry, std::string const &paramName,
1917  std::string const &sublistName) const;
1918 
1920  const std::string getXMLTypeName() const;
1921 
1923  void printDoc(std::string const &docString, std::ostream &out) const;
1924 
1926 
1927 private:
1928 
1931 
1934  ValidStringsList validStrings_;
1935 
1937 
1938 };
1939 
1945 template<>
1947 
1948 public:
1949 
1952 
1956  static RCP<StringValidator> getDummyObject();
1957 
1959 
1960 };
1961 
1962 
1966 template<class ValidatorType, class EntryType>
1968 
1969 public:
1970 
1973 
1982  prototypeValidator_(prototypeValidator){}
1983 
1985 
1988 
1991  return prototypeValidator_;
1992  }
1993 
1995 
1998 
2001  return prototypeValidator_->validStringValues();
2002  }
2003 
2005 
2006 private:
2007 
2010 
2014 
2017 
2019 
2020 };
2021 
2034 template<class ValidatorType, class EntryType>
2035 class TwoDArrayValidator : public AbstractArrayValidator<ValidatorType, EntryType>{
2036 public:
2039 
2047  AbstractArrayValidator<ValidatorType, EntryType>(prototypeValidator){}
2048 
2050 
2053 
2055  virtual void validate(ParameterEntry const &entry, std::string const &paramName,
2056  std::string const &sublistName) const;
2057 
2059  const std::string getXMLTypeName() const{
2060  return "TwoDArrayValidator(" +
2061  this->getPrototype()->getXMLTypeName() + ", " +
2063  }
2064 
2066  virtual void printDoc(std::string const &docString, std::ostream &out) const
2067  {
2068  StrUtils::printLines(out,"# ",docString);
2069  std::string toPrint;
2070  toPrint += "TwoDArrayValidator:\n";
2071  toPrint += "Prototype Validator:\n";
2072  this->getPrototype()->printDoc(toPrint, out);
2073  }
2074 
2076 
2077 };
2078 
2079 template<class ValidatorType, class EntryType>
2080 void TwoDArrayValidator<ValidatorType, EntryType>::validate(ParameterEntry const &entry, std::string const &paramName,
2081  std::string const &sublistName) const
2082 {
2083  any anyValue = entry.getAny(true);
2084  const std::string &entryName = entry.getAny(false).typeName();
2087  "The \"" << paramName << "\"" <<
2088  " parameter in the \"" << sublistName <<
2089  "\" sublist is has an error." << std::endl << std::endl <<
2090  "Error: The value you entered was the wrong type." << std::endl <<
2091  "Parameter: " << paramName << std::endl <<
2092  "Type specified: " << entryName << std::endl <<
2093  "Type accepted: " << TypeNameTraits<TwoDArray<EntryType> >::name() <<
2094  std::endl << std::endl);
2095 
2096  TwoDArray<EntryType> extracted =
2097  getValue<Teuchos::TwoDArray<EntryType> >(entry);
2098  RCP<const ParameterEntryValidator> prototype = this->getPrototype();
2099  for(int i = 0; i<extracted.getNumRows(); ++i){
2100  for(int j = 0; j<extracted.getNumCols(); ++j){
2101  ParameterEntry dummyParameter;
2102  dummyParameter.setValue(extracted(i,j));
2103  try{
2104  prototype->validate(
2105  dummyParameter, paramName, sublistName);
2106  }
2108  std::stringstream oss;
2109  oss << "TwoDArray Validator Exception:" << std::endl <<
2110  "Bad Index: (" << i << "," << j << ")" << std::endl << e.what();
2111  throw Exceptions::InvalidParameterValue(oss.str());
2112  }
2113  }
2114  }
2115 }
2116 
2117 
2123 template<class ValidatorType, class EntryType>
2124 class DummyObjectGetter<TwoDArrayValidator<ValidatorType, EntryType> >{
2125 
2126 public:
2127 
2130 
2135 
2137 
2138 };
2139 
2140 template<class ValidatorType, class EntryType>
2143 {
2146 }
2147 
2152  public TwoDArrayValidator<StringValidator, std::string>{
2153 
2154 public:
2155 
2158 
2161  TwoDArrayValidator<StringValidator, std::string>(prototypeValidator){}
2162 
2164 
2165 };
2166 
2167 
2173  public TwoDArrayValidator<FileNameValidator, std::string>{
2174 
2175 public:
2176 
2179 
2182  TwoDArrayValidator<FileNameValidator, std::string>(prototypeValidator){}
2183 
2185 
2186 };
2187 
2188 
2192 template<class T>
2193 class TwoDArrayNumberValidator : public TwoDArrayValidator<EnhancedNumberValidator<T>, T>{
2194 public:
2197 
2200  RCP<const EnhancedNumberValidator<T> > prototypeValidator):
2201  TwoDArrayValidator<EnhancedNumberValidator<T>, T>(prototypeValidator){}
2202 
2204 
2205 };
2206 
2207 
2219 template<class ValidatorType, class EntryType>
2220 class ArrayValidator : public AbstractArrayValidator<ValidatorType, EntryType>{
2221 
2222 public:
2223 
2226 
2233  AbstractArrayValidator<ValidatorType, EntryType>(prototypeValidator){}
2234 
2236 
2239 
2241  virtual void validate(ParameterEntry const &entry, std::string const &paramName,
2242  std::string const &sublistName) const;
2243 
2245  const std::string getXMLTypeName() const{
2246  return "ArrayValidator(" +
2247  this->getPrototype()->getXMLTypeName() + ", " +
2249  }
2250 
2252  virtual void printDoc(std::string const &docString, std::ostream &out) const
2253  {
2254  StrUtils::printLines(out,"# ",docString);
2255  std::string toPrint;
2256  toPrint += "ArrayValidator:\n";
2257  toPrint += "Prototype Validator:\n";
2258  this->getPrototype()->printDoc(toPrint, out);
2259  }
2260 
2262 
2263 };
2264 
2265 template<class ValidatorType, class EntryType>
2266 void ArrayValidator<ValidatorType, EntryType>::validate(ParameterEntry const &entry, std::string const &paramName,
2267  std::string const &sublistName) const
2268 {
2269  any anyValue = entry.getAny(true);
2270  const std::string &entryName = entry.getAny(false).typeName();
2271  TEUCHOS_TEST_FOR_EXCEPTION(anyValue.type() != typeid(Array<EntryType>),
2273  "The \"" << paramName << "\"" <<
2274  " parameter in the \"" << sublistName <<
2275  "\" sublist is has an error." << std::endl << std::endl <<
2276  "Error: The value you entered was the wrong type." << std::endl <<
2277  "Parameter: " << paramName << std::endl <<
2278  "Type specified: " << entryName << std::endl <<
2279  "Type accepted: " << TypeNameTraits<Array<EntryType> >::name() <<
2280  std::endl << std::endl);
2281 
2282  Array<EntryType> extracted =
2283  getValue<Teuchos::Array<EntryType> >(entry);
2284  RCP<const ParameterEntryValidator> prototype = this->getPrototype();
2285  for(int i = 0; i<extracted.size(); ++i){
2286  ParameterEntry dummyParameter;
2287  dummyParameter.setValue(extracted[i]);
2288  try{
2289  prototype->validate(
2290  dummyParameter, paramName, sublistName);
2291  }
2293  std::stringstream oss;
2294  oss << "Array Validator Exception:" << std::endl <<
2295  "Bad Index: " << i << std::endl << e.what();
2296  throw Exceptions::InvalidParameterValue(oss.str());
2297  }
2298  }
2299 }
2300 
2306 template<class ValidatorType, class EntryType>
2307 class DummyObjectGetter<ArrayValidator<ValidatorType, EntryType> >{
2308 
2309 public:
2310 
2313 
2318 
2320 
2321 };
2322 
2323 template<class ValidatorType, class EntryType>
2326 {
2329 }
2330 
2331 
2341  public ArrayValidator<StringValidator, std::string>{
2342 
2343 public:
2344 
2347 
2350  ArrayValidator<StringValidator, std::string>(prototypeValidator){}
2351 
2353 
2354 };
2355 
2356 
2365 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ArrayFileNameValidator : public ArrayValidator<FileNameValidator, std::string>{
2366 
2367 public:
2368 
2371 
2374  ArrayValidator<FileNameValidator, std::string>(prototypeValidator){}
2375 
2377 
2378 };
2379 
2380 
2388 template<class T>
2389 class ArrayNumberValidator : public ArrayValidator<EnhancedNumberValidator<T>, T>{
2390 public:
2393 
2396  RCP<const EnhancedNumberValidator<T> > prototypeValidator):
2397  ArrayValidator<EnhancedNumberValidator<T>, T>(prototypeValidator){}
2398 
2400 
2401 };
2402 
2403 
2404 
2405 // ///////////////////////////
2406 // Implementations
2407 
2408 
2409 //
2410 // StringToIntegralParameterEntryValidator
2411 //
2412 
2413 
2414 // Constructors
2415 
2416 
2417 template<class IntegralType>
2420  std::string const& defaultParameterName,
2421  const bool caseSensitive) :
2423  defaultParameterName_ (defaultParameterName),
2424  caseSensitive_ (caseSensitive)
2425 {
2426  typedef typename map_t::value_type val_t;
2427  for (int i = 0; i < static_cast<int> (strings.size ()); ++i) {
2428  const bool unique = caseSensitive_ ?
2429  map_.insert (val_t (strings[i], static_cast<IntegralType> (i))).second :
2430  map_.insert (val_t (upperCase (strings[i]), static_cast<IntegralType> (i))).second;
2432  ! unique, std::logic_error,
2433  "For parameter \"" << defaultParameterName_ << "\": "
2434  "strings[" << i << "] = \"" << strings[i] << "\" is a duplicate.");
2435  }
2436  setValidValues (strings);
2437 }
2438 
2439 
2440 template<class IntegralType>
2443  ArrayView<const IntegralType> const& integralValues,
2444  std::string const& defaultParameterName,
2445  const bool caseSensitive) :
2447  defaultParameterName_ (defaultParameterName),
2448  caseSensitive_ (caseSensitive)
2449 {
2450 #ifdef TEUCHOS_DEBUG
2451  TEUCHOS_ASSERT_EQUALITY( strings.size(), integralValues.size() );
2452 #endif
2454  strings.size() != integralValues.size(),
2455  std::logic_error,
2456  "The input arrays strings and integralValues must have the same length.");
2457 
2458  typedef typename map_t::value_type val_t;
2459  for (int i = 0; i < static_cast<int> (strings.size ()); ++i) {
2460  const bool unique = caseSensitive_ ?
2461  map_.insert (val_t (strings[i], integralValues[i])).second :
2462  map_.insert (val_t (upperCase (strings[i]), integralValues[i])).second;
2463 
2465  ! unique, std::logic_error,
2466  "For parameter \"" << defaultParameterName_ << "\": "
2467  "strings[" << i << "] = \"" << strings[i] << "\" is a duplicate.");
2468  }
2469  setValidValues (strings);
2470 }
2471 
2472 template<class IntegralType>
2475  ArrayView<const std::string> const& stringsDocs,
2476  ArrayView<const IntegralType> const& integralValues,
2477  std::string const& defaultParameterName,
2478  const bool caseSensitive) :
2480  defaultParameterName_ (defaultParameterName),
2481  caseSensitive_ (caseSensitive)
2482 {
2483 #ifdef TEUCHOS_DEBUG
2484  TEUCHOS_ASSERT_EQUALITY( strings.size(), stringsDocs.size() );
2485  TEUCHOS_ASSERT_EQUALITY( strings.size(), integralValues.size() );
2486 #endif
2487 
2489  strings.size() != integralValues.size(),
2490  std::logic_error,
2491  "The input arrays strings and integralValues must have the same length.");
2492 
2494  strings.size() != stringsDocs.size(),
2495  std::logic_error,
2496  "The input arrays strings and stringsDocs must have the same length.");
2497 
2498  typedef typename map_t::value_type val_t;
2499  for (int i = 0; i < static_cast<int> (strings.size ()); ++i) {
2500  const bool unique = caseSensitive_ ?
2501  map_.insert (val_t (strings[i], integralValues[i])).second :
2502  map_.insert (val_t (upperCase (strings[i]), integralValues[i])).second;
2504  ! unique, std::logic_error,
2505  "For parameter \"" << defaultParameterName_ << "\": "
2506  "strings[" << i << "] = \"" << strings[i] << "\" is a duplicate.");
2507  }
2508  setValidValues(strings,&stringsDocs);
2509 }
2510 
2511 // Lookup functions
2512 
2513 
2514 template<class IntegralType>
2515 IntegralType
2517  const std::string &str, const std::string &paramName
2518  ,const std::string &sublistName
2519  ) const
2520 {
2521  typename map_t::const_iterator itr = map_.find (caseSensitive_ ? str : upperCase (str));
2523  itr == map_.end(), Exceptions::InvalidParameterValue
2524  ,"Error, the value \"" << str << "\" is not recognized for the parameter \""
2525  << ( paramName.length() ? paramName : defaultParameterName_ ) << "\""
2526  << "\nin the sublist \"" << sublistName << "\"."
2527  << "\n\nValid values include:"
2528  << "\n {\n"
2529  << validValues_
2530  << " }"
2531  );
2532  return (*itr).second;
2533 }
2534 
2535 
2536 template<class IntegralType>
2537 IntegralType
2539  const ParameterEntry &entry, const std::string &paramName
2540  ,const std::string &sublistName, const bool activeQuery
2541  ) const
2542 {
2543  const bool validType = ( entry.getAny(activeQuery).type() == typeid(std::string) );
2546  ,"Error, the parameter {paramName=\""<<(paramName.length()?paramName:defaultParameterName_)
2547  << "\",type=\""<<entry.getAny(activeQuery).typeName()<<"\"}"
2548  << "\nin the sublist \"" << sublistName << "\""
2549  << "\nhas the wrong type."
2550  << "\n\nThe correct type is \"string\"!"
2551  );
2552  const std::string
2553  &strValue = any_cast<std::string>(entry.getAny(activeQuery)); // This cast should not fail!
2554  return getIntegralValue(strValue,paramName,sublistName); // This will validate the value and throw!
2555 }
2556 
2557 
2558 template<class IntegralType>
2559 std::string
2561  const ParameterEntry &entry, const std::string &paramName
2562  ,const std::string &sublistName, const bool activeQuery
2563  ) const
2564 {
2565  // Validate the parameter's type and value
2566  this->getIntegralValue(entry,paramName,sublistName,activeQuery);
2567  // Return the std::string value which is now validated!
2568  return any_cast<std::string>(entry.getAny(activeQuery)); // This cast should not fail!
2569 }
2570 
2571 
2572 template<class IntegralType>
2573 IntegralType
2575  ParameterList &paramList, const std::string &paramName
2576  ,const std::string &defaultValue
2577  ) const
2578 {
2579  const std::string& strValue =
2580  paramList.get (paramName,
2581  caseSensitive_ ? defaultValue : upperCase (defaultValue));
2582  return getIntegralValue (strValue, paramName, paramList.name ());
2583 }
2584 
2585 
2586 template<class IntegralType>
2587 std::string
2589  ParameterList &paramList, const std::string &paramName
2590  ,const std::string &defaultValue
2591  ) const
2592 {
2593  const std::string& strValue =
2594  paramList.get (paramName,
2595  caseSensitive_ ? defaultValue : upperCase (defaultValue));
2596  getIntegralValue(strValue,paramName,paramList.name()); // Validate!
2597  return strValue;
2598 }
2599 
2600 template<class IntegralType>
2603 {
2604  return validStringValuesDocs_;
2605 }
2606 
2607 template<class IntegralType>
2608 const std::string&
2610 {
2611  return defaultParameterName_;
2612 }
2613 
2614 template<class IntegralType>
2615 std::string
2617  const std::string &str, const std::string &paramName
2618  ,const std::string &sublistName
2619  ) const
2620 {
2621  getIntegralValue (caseSensitive_ ? str : upperCase (str),
2622  paramName,
2623  sublistName); // Validate!
2624  return str;
2625 }
2626 
2627 
2628 // Overridden from ParameterEntryValidator
2629 
2630 template<class IntegralType>
2631 const std::string
2633  return "StringIntegralValidator(" + TypeNameTraits<IntegralType>::name () + ")";
2634 }
2635 
2636 template<class IntegralType>
2638  std::string const& docString
2639  ,std::ostream & out
2640  ) const
2641 {
2642  StrUtils::printLines(out,"# ",docString);
2643  out << "# Valid std::string values:\n";
2644  out << "# {\n";
2645  if(validStringValuesDocs_.get()) {
2646  for( int i = 0; i < static_cast<int>(validStringValues_->size()); ++i ) {
2647  out << "# \"" << (*validStringValues_)[i] << "\"\n";
2648  StrUtils::printLines(out,"# ",(*validStringValuesDocs_)[i] );
2649  }
2650  }
2651  else {
2652  StrUtils::printLines(out,"# ",validValues_);
2653  // Note: Above validValues_ has for initial spaces already so indent should
2654  // be correct!
2655  }
2656  out << "# }\n";
2657 }
2658 
2659 
2660 template<class IntegralType>
2663 {
2664  return validStringValues_;
2665 }
2666 
2667 
2668 template<class IntegralType>
2670  ParameterEntry const& entry
2671  ,std::string const& paramName
2672  ,std::string const& sublistName
2673  ) const
2674 {
2675  this->getIntegralValue (entry, paramName, sublistName, false);
2676 }
2677 
2678 
2679 // private
2680 
2681 template<class IntegralType>
2683  ArrayView<const std::string> const& strings
2684  ,ArrayView<const std::string> const* stringsDocs
2685  )
2686 {
2687  if (caseSensitive_) {
2688  validStringValues_ = rcp (new Array<std::string> (strings));
2689  }
2690  else {
2691  RCP<Array<std::string> > vals (new Array<std::string> (strings.size ()));
2692  for (Array<std::string>::size_type i = 0; i < strings.size (); ++i) {
2693  (*vals)[i] = upperCase (strings[i]);
2694  }
2695  validStringValues_ = rcp_const_cast<const Array<std::string> > (vals);
2696  }
2697 
2698  if (stringsDocs) {
2699  validStringValuesDocs_ = rcp (new Array<std::string> (*stringsDocs));
2700  }
2701  // Build the list of valid values in the same order as passed in by the client.
2702  std::ostringstream oss;
2703  for (int i = 0; i < static_cast<int> (strings.size()); ++i) {
2704  oss << " \"" << strings[i] << "\"\n";
2705  }
2706  // Note: Above four spaces is designed for the error output above.
2707  validValues_ = oss.str();
2708 }
2709 
2710 
2711 } // namespace Teuchos
2712 
2713 
2714 //
2715 // Nonmember function implementations for StringToIntegralParameterEntryValidator
2716 //
2717 
2718 
2719 template<class IntegralType>
2720 inline
2722 Teuchos::stringToIntegralParameterEntryValidator(
2723  ArrayView<const std::string> const& strings,
2724  std::string const& defaultParameterName
2725  )
2726 {
2727  return rcp(
2728  new StringToIntegralParameterEntryValidator<IntegralType>(
2729  strings, defaultParameterName
2730  )
2731  );
2732 }
2733 
2734 
2735 template<class IntegralType>
2736 inline
2738 Teuchos::stringToIntegralParameterEntryValidator(
2739  ArrayView<const std::string> const& strings,
2740  std::string const& defaultParameterName,
2741  const bool caseSensitive
2742  )
2743 {
2744  typedef StringToIntegralParameterEntryValidator<IntegralType> ret_type;
2745  return rcp (new ret_type (strings, defaultParameterName, caseSensitive));
2746 }
2747 
2748 
2749 
2750 template<class IntegralType>
2751 inline
2753 Teuchos::stringToIntegralParameterEntryValidator(
2754  ArrayView<const std::string> const& strings,
2755  ArrayView<const IntegralType> const& integralValues,
2756  std::string const& defaultParameterName
2757  )
2758 {
2759  return rcp(
2760  new StringToIntegralParameterEntryValidator<IntegralType>(
2761  strings, integralValues, defaultParameterName
2762  )
2763  );
2764 }
2765 
2766 
2767 template<class IntegralType>
2768 inline
2770 Teuchos::stringToIntegralParameterEntryValidator(
2771  ArrayView<const std::string> const& strings,
2772  ArrayView<const IntegralType> const& integralValues,
2773  std::string const& defaultParameterName,
2774  const bool caseSensitive)
2775 {
2776  typedef StringToIntegralParameterEntryValidator<IntegralType> ret_type;
2777  return rcp (new ret_type (strings, integralValues,
2778  defaultParameterName, caseSensitive));
2779 }
2780 
2781 
2782 template<class IntegralType>
2783 inline
2785 Teuchos::stringToIntegralParameterEntryValidator(
2786  ArrayView<const std::string> const& strings,
2787  ArrayView<const std::string> const& stringsDocs,
2788  ArrayView<const IntegralType> const& integralValues,
2789  std::string const& defaultParameterName
2790  )
2791 {
2792  return rcp(
2793  new StringToIntegralParameterEntryValidator<IntegralType>(
2794  strings, stringsDocs, integralValues, defaultParameterName
2795  )
2796  );
2797 }
2798 
2799 
2800 template<class IntegralType>
2801 inline
2803 Teuchos::stringToIntegralParameterEntryValidator(
2804  ArrayView<const std::string> const& strings,
2805  ArrayView<const std::string> const& stringsDocs,
2806  ArrayView<const IntegralType> const& integralValues,
2807  std::string const& defaultParameterName,
2808  const bool caseSensitive)
2809 {
2810  typedef StringToIntegralParameterEntryValidator<IntegralType> ret_type;
2811  return rcp (new ret_type (strings, stringsDocs, integralValues,
2812  defaultParameterName, caseSensitive));
2813 }
2814 
2815 
2816 template<class IntegralType>
2817 void Teuchos::setStringToIntegralParameter(
2818  std::string const& paramName,
2819  std::string const& defaultValue,
2820  std::string const& docString,
2821  ArrayView<const std::string> const& strings,
2822  ParameterList * paramList
2823  )
2824 {
2825  typedef ParameterEntryValidator PEV;
2826  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
2827  paramList->set(
2828  paramName, defaultValue, docString,
2829  rcp_implicit_cast<const PEV>(
2830  stringToIntegralParameterEntryValidator<IntegralType>(
2831  strings, paramName
2832  )
2833  )
2834  );
2835 }
2836 
2837 
2838 template<class IntegralType>
2839 void Teuchos::setStringToIntegralParameter(
2840  std::string const& paramName,
2841  std::string const& defaultValue,
2842  std::string const& docString,
2843  ArrayView<const std::string> const& strings,
2844  ArrayView<const IntegralType> const& integralValues,
2845  ParameterList * paramList
2846  )
2847 {
2848  typedef ParameterEntryValidator PEV;
2849  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
2850  paramList->set(
2851  paramName, defaultValue, docString,
2852  rcp_implicit_cast<const PEV>(
2853  stringToIntegralParameterEntryValidator<IntegralType>(
2854  strings, integralValues, paramName
2855  )
2856  )
2857  );
2858 }
2859 
2860 
2861 template<class IntegralType>
2862 void Teuchos::setStringToIntegralParameter(
2863  std::string const& paramName,
2864  std::string const& defaultValue,
2865  std::string const& docString,
2866  ArrayView<const std::string> const& strings,
2867  ArrayView<const std::string> const& stringsDocs,
2868  ArrayView<const IntegralType> const& integralValues,
2869  ParameterList * paramList
2870  )
2871 
2872 {
2873  typedef ParameterEntryValidator PEV;
2874  TEUCHOS_TEST_FOR_EXCEPT(0==paramList);
2875  paramList->set(
2876  paramName, defaultValue, docString,
2877  rcp_implicit_cast<const PEV>(
2878  stringToIntegralParameterEntryValidator<IntegralType>(
2879  strings, stringsDocs, integralValues, paramName
2880  )
2881  )
2882  );
2883 }
2884 
2885 
2886 template<class IntegralType>
2887 IntegralType Teuchos::getIntegralValue(
2888  ParameterList const& paramList, std::string const& paramName
2889  )
2890 {
2891  const ParameterEntry &entry = paramList.getEntry(paramName);
2892  RCP<const StringToIntegralParameterEntryValidator<IntegralType> >
2893  integralValidator = getStringToIntegralParameterEntryValidator<IntegralType>(
2894  entry, paramList, paramName
2895  );
2896  return integralValidator->getIntegralValue(
2897  entry, paramName, paramList.name(), true );
2898 }
2899 
2900 
2901 template<class IntegralType>
2902 std::string Teuchos::getStringValue(
2903  ParameterList const& paramList, std::string const& paramName
2904  )
2905 {
2906  const ParameterEntry &entry = paramList.getEntry(paramName);
2907  RCP<const StringToIntegralParameterEntryValidator<IntegralType> >
2908  integralValidator = getStringToIntegralParameterEntryValidator<IntegralType>(
2909  entry, paramList, paramName
2910  );
2911  return integralValidator->getStringValue(
2912  entry, paramName, paramList.name(), true
2913  );
2914 }
2915 
2916 
2917 template<class IntegralType>
2920  ParameterEntry const& entry, ParameterList const& paramList,
2921  std::string const& paramName
2922  )
2923 {
2924  const RCP<const ParameterEntryValidator> validator = entry.validator();
2926  is_null(validator), Exceptions::InvalidParameterType,
2927  "Error! The parameter \""<<paramName<<"\" exists\n"
2928  "in the parameter (sub)list \""<<paramList.name()<<"\"\n"
2929  "but it does not contain any validator needed to extract\n"
2930  "an integral value of type \""<<TypeNameTraits<IntegralType>::name()<<"\"!"
2931  );
2932  const RCP<const StringToIntegralParameterEntryValidator<IntegralType> > integralValidator =
2933  rcp_dynamic_cast<const StringToIntegralParameterEntryValidator<IntegralType> >(
2934  validator
2935  );
2937  is_null(integralValidator), Exceptions::InvalidParameterType,
2938  "Error! The parameter \""<<paramName<<"\" exists\n"
2939  "in the parameter (sub)list \""<<paramList.name()<<"\"\n"
2940  "but it contains the wrong type of validator. The expected validator type\n"
2941  "is \""<<TypeNameTraits<StringToIntegralParameterEntryValidator<IntegralType> >::name()<<"\"\n"
2942  "but the contained validator type is \""<<typeName(*validator)<<"\"!"
2943  );
2944  return integralValidator;
2945 }
2946 
2947 
2948 #endif // TEUCHOS_STANDARD_PARAMETER_ENTRY_VALIDATORS_H
static bool mustAlreadyExistDefault()
The default value of the mustAlreadyExist parameter in the constructor.
A thin wrapper around the Teuchos Array class that allows for 2 dimensional arrays.
std::string validateString(const std::string &str, const std::string &paramName="", const std::string &sublistName="") const
Validate the std::string and pass it on.
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...
const std::string & name() const
The name of this ParameterList.
T getMax() const
Gets the maximum acceptable value for the validator.
bool isCaseSensitive() const
Whether this validator is case sensitive.
EVerbosityLevel
Verbosity level.
EnhancedNumberValidator()
Constructs a EnhancedNumberValidator without an explicit minimum or maximum.
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
Convience class for StringValidators that are to be applied to TwoDArrays.
void printDoc(std::string const &docString, std::ostream &out) const
Print documentation to the given output string.
static RCP< T > getDummyObject()
Retrieves a dummy object of type T.
RCP< const StringToIntegralParameterEntryValidator< IntegralType > > getStringToIntegralParameterEntryValidator(ParameterEntry const &entry, ParameterList const &paramList, std::string const &paramName)
Get a StringToIntegralParameterEntryValidator&lt;IntegralType&gt; object out of a ParameterEntry object...
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.
Convience class for EnhancedNumberValidators that are to be applied to arrays.
void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)
Dynamic cast of underlying RCP type from T1* to T2*.
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.
T minVal
The minimum value accepted by the validator.
virtual void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
Default structure used by EnhancedNumberTraits&lt;T&gt; to produce a compile time error when the specializa...
void setMax(T max)
Sets the maximum acceptable value for the validator.
size_type size() const
The total number of items in the managed array.
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.
bool hasMax() const
Determines whether or not the validator has a maximum value.
T getMin() const
Gets the minimum acceptable value for the validator.
static std::ostream & printLines(std::ostream &os, const std::string &linePrefix, const std::string &lines)
Print lines with prefix first.
ValidStringsList validStrings_
An array containing a list of all the valid string values.
AbstractArrayValidator()
Hidden default constructor.
Modified boost::any class, which is a container for a templated value.
static EPreferredType getPrefferedTypeStringEnum(const std::string &enumString)
Gets the preferred type enum associated with a give string.
bool is_null(const ArrayRCP< T > &p)
Returns true if p.get()==NULL.
AcceptedTypes & allowInt(bool _allowInt)
Set allow an int value or not.
AbstractArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs an AbstractArrayValidator.
Takes a validator, wraps it, and applies it to a TwoDArray.
bool hasMin() const
Determines whether or not the validator has a minimum value.
unsigned short getPrecision() const
Gets the precision specified for the validator.
virtual void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
Validate and perhaps modify a parameter entry&#39;s value.
A std::string utilities class for Teuchos.
A thin wrapper around the Array class which causes it to be interpreted as a 2D Array.
RCP< const ValidatorType > getPrototype() const
Returns the prototype validator for this Array Validator.
void printDoc(std::string const &docString, std::ostream &out) const
Convience class for StringValidators that are to be applied to arrays.
static T notDefined()
This function should not compile if there is an attempt to instantiate!
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Templated Parameter List class.
static unsigned short defaultPrecision()
Gets the default precision with which the number type should be displayed.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
Validate the given ParameterEntry.
bool containsMax
Whetehr or not a maximum value has been specified for this validator.
Teuchos::any getNumberFromString(const ParameterEntry &entry, const bool activeQuery) const
std::string toString(const HashSet< Key > &h)
std::string getStringValue(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Find the string value for the given ParameterEntry.
ArrayStringValidator(RCP< const StringValidator > prototypeValidator)
Convience class for EnhancedNumberValidators that are to be applied to TwoDArray. ...
An abstract base class for all ArrayValidators.
Standard implementation of a BoolParameterEntryValidator that accepts bool values (true/false) or str...
ArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs a ArrayValidator.
Convience class for FileNameValidators that are to be applied to TwoDArrays.
AcceptedTypes(bool allowAllTypesByDefault=true)
Allow all types or not on construction.
void setStep(T step)
Sets the step being used for the validator.
Takes a validator, wraps it, and applies it to an array.
A list of parameters of arbitrary type.
bool mustAlreadyExist_
Whether or not the file specified in the parameter should already exist.
A simple validator that only allows certain string values to be choosen or simply enforces that a par...
static T min()
Gets the minimum possible value the number type can take on.
#define TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT
TwoDArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs a ArrayValidator.
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...
void setPrecision(unsigned short precision)
Sets the precision specified for the validator.
IntegralType getIntegralValue(const std::string &str, const std::string &paramName="", const std::string &sublistName="") const
For a string value, find its corresponding enum or integer value.
void setMin(T min)
Sets the minimum acceptable value for the validator.
EnhancedNumberValidator(T min, T max, T step=EnhancedNumberTraits< T >::defaultStep(), unsigned short precision=EnhancedNumberTraits< T >::defaultPrecision())
Constructs a EnhancedNumberValidator.
virtual void printDoc(std::string const &docString, std::ostream &out) const
Nonowning array view.
RCP< const Array< std::string > > ValidStringsList
Default traits class that just returns typeid(T).name().
Class for retrieving a dummy object of type T.
unsigned short precision_
The number of decimal places with which the nubmer will be displayed in a UI. This value is meaningle...
static const std::string & getPrefferedTypeString(EPreferredType enumValue)
Gets the string representation of a given preferred type enum.
static std::string upperCase(const std::string s)
Return an upper-case copy of the string s.
ArrayFileNameValidator(RCP< const FileNameValidator > prototypeValidator)
static T defaultStep()
gets default amount a value of the number type should be incremented by when being utilizied in a UI...
static T max()
Gets the maximum possible value the number type can take on.
Class uesd to validate a particular type of number.
Convience class for FileNameValidators that are to be applied to arrays.
void setValidValues(ArrayView< const std::string > const &strings, ArrayView< const std::string > const *stringsDocs=NULL)
Class defining the traits of the number type being used in an EnhancedNumberValidator.
virtual void printDoc(std::string const &docString, std::ostream &out) const
std::string typeName() const
Return the name of the type.
TwoDArrayNumberValidator(RCP< const EnhancedNumberValidator< T > > prototypeValidator)
AcceptedTypes & allowDouble(bool _allowDouble)
Set allow a double value or not.
ValidStringsList getStringDocs() const
Get a pointer to the array containing all the documentation strings.
Smart reference counting pointer class for automatic garbage collection.
TwoDArrayStringValidator(RCP< const StringValidator > prototypeValidator)
const std::type_info & type() const
Return the type of value being stored.
TwoDArrayFileNameValidator(RCP< const FileNameValidator > prototypeValidator)
virtual void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
#define TEUCHOS_ASSERT_EQUALITY(val1, val2)
This macro is checks that to numbers are equal and if not then throws an exception with a good error ...
const std::string & getDefaultParameterName() const
Get the name of the default parameter for the validator.
T step_
The increment to use when increaseing or decreaseing the value the validator is validating.
Standard implementation of a ParameterEntryValidator that accepts numbers from a number of different ...
T getStep() const
Gets the step being used for the validator.
Defines basic traits returning the name of a type in a portable and readable way. ...
AcceptedTypes & allowLongLong(bool _allowLongLong)
Set allow an long long value or not.
bool containsMin
Whether or not a minimum value has been specified for this validator.
#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...
T maxVal
The maximum value accepted by the validator.
RCP< const ValidatorType > prototypeValidator_
The prototype validator to be applied to each entry in the Array.
#define TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
ArrayNumberValidator(RCP< const EnhancedNumberValidator< T > > prototypeValidator)