Teuchos - Trilinos Tools Package  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Teuchos_StandardParameterEntryValidators.hpp
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 
45 #include "Teuchos_ParameterEntryValidator.hpp"
47 #include "Teuchos_ParameterListExceptions.hpp"
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:
324  std::string defaultParameterName_;
325  std::string validValues_;
326  ValidStringsList validStringValues_;
327  ValidStringsList validStringValuesDocs_;
328 
329  typedef std::map<std::string,IntegralType> map_t;
330  map_t map_;
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 
603 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT BoolParameterEntryValidator
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 
692 TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<BoolParameterEntryValidator>
693 boolParameterEntryValidator();
694 
695 
709 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT AnyNumberParameterEntryValidator
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_;
753  bool allowLongLong_;
754  bool allowDouble_;
755  bool allowString_;
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 
952  EPreferredType preferredType_;
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
960  const AcceptedTypes acceptedTypes_;
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<>
1163 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<AnyNumberParameterEntryValidator>{
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<>
1259 class EnhancedNumberTraits<int>{
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<>
1350 class EnhancedNumberTraits<float>{
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 
1560  T minVal;
1561 
1564  T maxVal;
1565 
1568  T step_;
1569 
1573  unsigned short precision_;
1574 
1577  bool containsMin;
1578 
1581  bool containsMax;
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 
1734 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT FileNameValidator : public ParameterEntryValidator {
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 
1839  bool mustAlreadyExist_;
1840  bool EmptyNameOK_;
1841 
1843 
1844 };
1845 
1851 template<>
1852 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<FileNameValidator>{
1853 
1854 public:
1855 
1858 
1862  static RCP<FileNameValidator> getDummyObject();
1863 
1865 
1866 };
1867 
1875 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT StringValidator : public ParameterEntryValidator {
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<>
1946 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<StringValidator>{
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 
2013  RCP<const ValidatorType> prototypeValidator_;
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 
2151 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT TwoDArrayStringValidator :
2152  public TwoDArrayValidator<StringValidator, std::string>{
2153 
2154 public:
2155 
2158 
2161  TwoDArrayValidator<StringValidator, std::string>(prototypeValidator){}
2162 
2164 
2165 };
2166 
2167 
2172 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT TwoDArrayFileNameValidator :
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 
2340 class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ArrayStringValidator :
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>
2418 StringToIntegralParameterEntryValidator<IntegralType>::
2419 StringToIntegralParameterEntryValidator (ArrayView<const std::string> const& strings,
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.
EnhancedNumberValidator()
Constructs a EnhancedNumberValidator without an explicit minimum or maximum.
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.
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.
EVerbosityLevel
Verbosity level.
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!
Ordinal size_type
The type of Array sizes and capacities.
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.
Teuchos::any getNumberFromString(const ParameterEntry &entry, const bool activeQuery) const
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.
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.
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.
static const std::string & getPrefferedTypeString(EPreferredType enumValue)
Gets the string representation of a given preferred type enum.
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.
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.
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.
#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...
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
#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)