Teuchos - Trilinos Tools Package Version of the Day
Loading...
Searching...
No Matches
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
62namespace Teuchos {
63
91template<class IntegralType>
93public:
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
216 const std::string &paramName = "",
217 const std::string &sublistName = "",
218 const bool activeQuery = true) const;
219
235 std::string
237 const std::string &paramName = "",
238 const std::string &sublistName = "",
239 const bool activeQuery = true) const;
240
247 IntegralType
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
306 std::string const& docString,
307 std::ostream & out
308 ) const;
309
313
316 ParameterEntry const& entry,
317 std::string const& paramName,
318 std::string const& sublistName
319 ) const;
320
322
323private:
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
355template<class IntegralType>
356RCP<StringToIntegralParameterEntryValidator<IntegralType> >
358 ArrayView<const std::string> const& strings,
359 std::string const& defaultParameterName
360 );
361
362
367template<class IntegralType>
370 ArrayView<const std::string> const& strings,
371 std::string const& defaultParameterName,
372 const bool caseSensitive
373 );
374
375
380template<class IntegralType>
383 ArrayView<const std::string> const& strings,
384 ArrayView<const IntegralType> const& integralValues,
385 std::string const& defaultParameterName
386 );
387
388
393template<class IntegralType>
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
407template<class IntegralType>
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
421template<class IntegralType>
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
442template<class IntegralType>
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
463template<class IntegralType>
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
485template<class IntegralType>
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
507template<class IntegralType>
508IntegralType getIntegralValue(
509 ParameterList const& paramList, std::string const& paramName
510 );
511
512
524template<class IntegralType>
525std::string getStringValue(
526 ParameterList const& paramList, std::string const& paramName
527 );
528
529
535template<class IntegralType>
538 ParameterEntry const& entry, ParameterList const& paramList,
539 std::string const& paramName
540 );
541
542
548std::string getVerbosityLevelParameterValueName(
549 const EVerbosityLevel verbLevel
550 );
551
552
558verbosityLevelParameterEntryValidator(std::string const& defaultParameterName);
559
565template<class IntegralType>
567
568public:
569
572
578
580};
581
582template<class IntegralType>
585{
586 return stringToIntegralParameterEntryValidator<IntegralType>(
587 tuple<std::string>(""), tuple<std::string>(""),
588 tuple<IntegralType>((IntegralType)1), "");
589}
590
603class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT BoolParameterEntryValidator
605{
606public:
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
666private:
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
692TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<BoolParameterEntryValidator>
694
695
709class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT AnyNumberParameterEntryValidator
711{
712public:
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
947private:
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
1011TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<AnyNumberParameterEntryValidator>
1013
1014
1019TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP<AnyNumberParameterEntryValidator>
1023 );
1024
1030TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setIntParameter(
1031 std::string const& paramName,
1032 int const value, std::string const& docString,
1033 ParameterList *paramList,
1036 );
1037
1038
1044TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setLongLongParameter(
1045 std::string const& paramName,
1046 long long const value, std::string const& docString,
1047 ParameterList *paramList,
1050 );
1051
1057TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setDoubleParameter(
1058 std::string const& paramName,
1059 double const& value, std::string const& docString,
1060 ParameterList *paramList,
1063 );
1064
1065
1071TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setNumericStringParameter(
1072 std::string const& paramName,
1073 std::string const& value, std::string const& docString,
1074 ParameterList *paramList,
1077 );
1078
1079
1094TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT int getIntParameter(
1095 ParameterList const& paramList, std::string const& paramName
1096 );
1097
1098
1113TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT long long getLongLongParameter(
1114 ParameterList const& paramList, std::string const& paramName
1115 );
1116
1131TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT double getDoubleParameter(
1132 ParameterList const& paramList,
1133 std::string const& paramName
1134 );
1135
1136
1152TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT std::string getNumericStringParameter(
1153 ParameterList const& paramList,
1154 std::string const& paramName
1155 );
1156
1162template<>
1163class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<AnyNumberParameterEntryValidator>{
1164
1165public:
1166
1169
1173 static RCP<AnyNumberParameterEntryValidator > getDummyObject();
1174
1176
1177};
1178
1179
1184template <class T>
1187 static inline T notDefined() {
1188 return T::this_type_is_missing_a_specialization();
1189 }
1190};
1191
1192
1213template <class T>
1215public:
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
1238template<>
1239class EnhancedNumberTraits<short int>{
1240public:
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
1248template<>
1249class EnhancedNumberTraits<short unsigned int>{
1250public:
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
1258template<>
1259class EnhancedNumberTraits<int>{
1260public:
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
1268template<>
1269class EnhancedNumberTraits<unsigned int>{
1270public:
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
1278template<>
1279class EnhancedNumberTraits<long int>{
1280public:
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
1288template<>
1289class EnhancedNumberTraits<long unsigned int>{
1290public:
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
1298template<>
1299class EnhancedNumberTraits<long long int>{
1300public:
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
1308template<>
1309class EnhancedNumberTraits<long long unsigned int>{
1310public:
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
1319template<>
1320class EnhancedNumberTraits<__float128>{
1321public:
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
1329template<>
1330class EnhancedNumberTraits<double>{
1331public:
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
1339template<>
1340class EnhancedNumberTraits<long double>{
1341public:
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
1349template<>
1350class EnhancedNumberTraits<float>{
1351public:
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
1363template <class T>
1365
1366public:
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
1543private:
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
1587template<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
1612template<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
1637template<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
1655template<class T>
1656void 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
1703template<class T>
1705
1706public:
1707
1710
1715
1717};
1718
1719template<class T>
1722{
1723 return rcp(new EnhancedNumberValidator<T>);
1724}
1725
1734class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT FileNameValidator : public ParameterEntryValidator {
1735
1736public:
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
1831private:
1832
1835
1839 bool mustAlreadyExist_;
1840 bool EmptyNameOK_;
1841
1843
1844};
1845
1851template<>
1852class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<FileNameValidator>{
1853
1854public:
1855
1858
1862 static RCP<FileNameValidator> getDummyObject();
1863
1865
1866};
1867
1875class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT StringValidator : public ParameterEntryValidator {
1876
1877public:
1878
1881
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
1927private:
1928
1931
1934 ValidStringsList validStrings_;
1935
1937
1938};
1939
1945template<>
1946class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT DummyObjectGetter<StringValidator>{
1947
1948public:
1949
1952
1956 static RCP<StringValidator> getDummyObject();
1957
1959
1960};
1961
1962
1966template<class ValidatorType, class EntryType>
1968
1969public:
1970
1973
1982 prototypeValidator_(prototypeValidator){}
1983
1985
1988
1991 return prototypeValidator_;
1992 }
1993
1995
1998
2001 return prototypeValidator_->validStringValues();
2002 }
2003
2005
2006private:
2007
2010
2013 RCP<const ValidatorType> prototypeValidator_;
2014
2017
2019
2020};
2021
2034template<class ValidatorType, class EntryType>
2035class TwoDArrayValidator : public AbstractArrayValidator<ValidatorType, EntryType>{
2036public:
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
2079template<class ValidatorType, class EntryType>
2080void 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
2123template<class ValidatorType, class EntryType>
2124class DummyObjectGetter<TwoDArrayValidator<ValidatorType, EntryType> >{
2125
2126public:
2127
2130
2135
2137
2138};
2139
2140template<class ValidatorType, class EntryType>
2143{
2146}
2147
2151class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT TwoDArrayStringValidator :
2152 public TwoDArrayValidator<StringValidator, std::string>{
2153
2154public:
2155
2158
2161 TwoDArrayValidator<StringValidator, std::string>(prototypeValidator){}
2162
2164
2165};
2166
2167
2172class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT TwoDArrayFileNameValidator :
2173 public TwoDArrayValidator<FileNameValidator, std::string>{
2174
2175public:
2176
2179
2182 TwoDArrayValidator<FileNameValidator, std::string>(prototypeValidator){}
2183
2185
2186};
2187
2188
2192template<class T>
2193class TwoDArrayNumberValidator : public TwoDArrayValidator<EnhancedNumberValidator<T>, T>{
2194public:
2197
2200 RCP<const EnhancedNumberValidator<T> > prototypeValidator):
2201 TwoDArrayValidator<EnhancedNumberValidator<T>, T>(prototypeValidator){}
2202
2204
2205};
2206
2207
2219template<class ValidatorType, class EntryType>
2220class ArrayValidator : public AbstractArrayValidator<ValidatorType, EntryType>{
2221
2222public:
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
2265template<class ValidatorType, class EntryType>
2266void 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
2306template<class ValidatorType, class EntryType>
2307class DummyObjectGetter<ArrayValidator<ValidatorType, EntryType> >{
2308
2309public:
2310
2313
2318
2320
2321};
2322
2323template<class ValidatorType, class EntryType>
2326{
2329}
2330
2331
2340class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ArrayStringValidator :
2341 public ArrayValidator<StringValidator, std::string>{
2342
2343public:
2344
2347
2350 ArrayValidator<StringValidator, std::string>(prototypeValidator){}
2351
2353
2354};
2355
2356
2365class TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT ArrayFileNameValidator : public ArrayValidator<FileNameValidator, std::string>{
2366
2367public:
2368
2371
2374 ArrayValidator<FileNameValidator, std::string>(prototypeValidator){}
2375
2377
2378};
2379
2380
2388template<class T>
2389class ArrayNumberValidator : public ArrayValidator<EnhancedNumberValidator<T>, T>{
2390public:
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
2417template<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
2440template<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
2472template<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
2514template<class IntegralType>
2515IntegralType
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
2536template<class IntegralType>
2537IntegralType
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
2558template<class IntegralType>
2559std::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
2572template<class IntegralType>
2573IntegralType
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
2586template<class IntegralType>
2587std::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
2600template<class IntegralType>
2603{
2604 return validStringValuesDocs_;
2605}
2606
2607template<class IntegralType>
2608const std::string&
2610{
2611 return defaultParameterName_;
2612}
2613
2614template<class IntegralType>
2615std::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
2630template<class IntegralType>
2631const std::string
2633 return "StringIntegralValidator(" + TypeNameTraits<IntegralType>::name () + ")";
2634}
2635
2636template<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
2660template<class IntegralType>
2663{
2664 return validStringValues_;
2665}
2666
2667
2668template<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
2681template<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
2719template<class IntegralType>
2720inline
2722Teuchos::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
2735template<class IntegralType>
2736inline
2738Teuchos::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
2750template<class IntegralType>
2751inline
2753Teuchos::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
2767template<class IntegralType>
2768inline
2770Teuchos::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
2782template<class IntegralType>
2783inline
2785Teuchos::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
2800template<class IntegralType>
2801inline
2803Teuchos::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
2816template<class IntegralType>
2817void 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
2838template<class IntegralType>
2839void 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
2861template<class IntegralType>
2862void 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
2886template<class IntegralType>
2887IntegralType 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
2901template<class IntegralType>
2902std::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
2917template<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
Templated Parameter List class.
A std::string utilities class for Teuchos.
A thin wrapper around the Teuchos Array class that allows for 2 dimensional arrays.
Defines basic traits returning the name of a type in a portable and readable way.
An abstract base class for all ArrayValidators.
RCP< const ValidatorType > getPrototype() const
Returns the prototype validator for this Array Validator.
AbstractArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs an AbstractArrayValidator.
AcceptedTypes & allowInt(bool _allowInt)
Set allow an int value or not.
AcceptedTypes & allowDouble(bool _allowDouble)
Set allow a double value or not.
AcceptedTypes & allowLongLong(bool _allowLongLong)
Set allow an long long value or not.
AcceptedTypes & allowString(bool _allowString)
Set allow an std::string value or not.
AcceptedTypes(bool allowAllTypesByDefault=true)
Allow all types or not on construction.
Standard implementation of a ParameterEntryValidator that accepts numbers from a number of different ...
static EPreferredType getPrefferedTypeStringEnum(const std::string &enumString)
Gets the preferred type enum associated with a give string.
static const std::string & getPrefferedTypeString(EPreferredType enumValue)
Gets the string representation of a given preferred type enum.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< AnyNumberParameterEntryValidator > anyNumberParameterEntryValidator()
Nonmember constructor AnyNumberParameterEntryValidator.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< AnyNumberParameterEntryValidator > anyNumberParameterEntryValidator(AnyNumberParameterEntryValidator::EPreferredType const preferredType, AnyNumberParameterEntryValidator::AcceptedTypes const &acceptedTypes)
Nonmember constructor AnyNumberParameterEntryValidator.
Convience class for FileNameValidators that are to be applied to arrays.
ArrayFileNameValidator(RCP< const FileNameValidator > prototypeValidator)
Convience class for EnhancedNumberValidators that are to be applied to arrays.
ArrayNumberValidator(RCP< const EnhancedNumberValidator< T > > prototypeValidator)
Convience class for StringValidators that are to be applied to arrays.
ArrayStringValidator(RCP< const StringValidator > prototypeValidator)
Takes a validator, wraps it, and applies it to an array.
ArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs a ArrayValidator.
virtual void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
virtual void printDoc(std::string const &docString, std::ostream &out) const
Nonowning array view.
size_type size() const
The total number of items in the managed array.
Replacement for std::vector that is compatible with the Teuchos Memory Management classes.
size_type size() const
Standard implementation of a BoolParameterEntryValidator that accepts bool values (true/false) or str...
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< BoolParameterEntryValidator > boolParameterEntryValidator()
Nonmember constructor BoolParameterEntryValidator.
Class for retrieving a dummy object of type T.
static RCP< T > getDummyObject()
Retrieves a dummy object of type T.
Class defining the traits of the number type being used in an EnhancedNumberValidator.
static T max()
Gets the maximum possible value the number type can take on.
static unsigned short defaultPrecision()
Gets the default precision with which the number type should be displayed.
static T defaultStep()
gets default amount a value of the number type should be incremented by when being utilizied in a UI.
static T min()
Gets the minimum possible value the number type can take on.
Class uesd to validate a particular type of number.
T getMax() const
Gets the maximum acceptable value for the validator.
Teuchos::any getNumberFromString(const ParameterEntry &entry, const bool activeQuery) const
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.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
void setMax(T max)
Sets the maximum acceptable value for the validator.
void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
T getStep() const
Gets the step being used for the validator.
unsigned short getPrecision() const
Gets the precision specified for the validator.
void setStep(T step)
Sets the step being used for the validator.
bool hasMax() const
Determines whether or not the validator has a maximum value.
T getMin() const
Gets the minimum acceptable value for the validator.
void setPrecision(unsigned short precision)
Sets the precision specified for the validator.
void printDoc(std::string const &docString, std::ostream &out) const
EnhancedNumberValidator()
Constructs a EnhancedNumberValidator without an explicit minimum or maximum.
bool hasMin() const
Determines whether or not the validator has a minimum value.
static bool mustAlreadyExistDefault()
The default value of the mustAlreadyExist parameter in the constructor.
Abstract interface for an object that can validate a ParameterEntry's value.
virtual void validateAndModify(std::string const &paramName, std::string const &sublistName, ParameterEntry *entry) const
Validate and perhaps modify a parameter entry's value.
This object is held as the "value" in the Teuchos::ParameterList std::map.
any & getAny(bool activeQry=true)
Direct access to the Teuchos::any data value underlying this object. The bool argument activeQry (def...
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.
A list of parameters of arbitrary type.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT std::string getNumericStringParameter(ParameterList const &paramList, std::string const &paramName)
Get std::string numeric parameter.
void setStringToIntegralParameter(std::string const &paramName, std::string const &defaultValue, std::string const &docString, ArrayView< const std::string > const &strings, ArrayView< const std::string > const &stringsDocs, ArrayView< const IntegralType > const &integralValues, ParameterList *paramList)
Set up a std::string parameter with documentation strings for each valid value that will use an embed...
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setDoubleParameter(std::string const &paramName, double const &value, std::string const &docString, ParameterList *paramList, AnyNumberParameterEntryValidator::AcceptedTypes const &acceptedTypes=AnyNumberParameterEntryValidator::AcceptedTypes())
Set an double parameter that allows for (nearly) any input parameter type that is convertible to a do...
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setLongLongParameter(std::string const &paramName, long long const value, std::string const &docString, ParameterList *paramList, AnyNumberParameterEntryValidator::AcceptedTypes const &acceptedTypes=AnyNumberParameterEntryValidator::AcceptedTypes())
Set an integer parameter that allows for (nearly) any input parameter type that is convertible to an ...
void setStringToIntegralParameter(std::string const &paramName, std::string const &defaultValue, std::string const &docString, ArrayView< const std::string > const &strings, ArrayView< const IntegralType > const &integralValues, ParameterList *paramList)
Set up a std::string parameter that will use an embedded validator to allow the extraction of an inte...
const std::string & name() const
The name of this ParameterList.
IntegralType getIntegralValue(ParameterList const &paramList, std::string const &paramName)
Get an integral value for a parameter that is assumed to already be set.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT double getDoubleParameter(ParameterList const &paramList, std::string const &paramName)
Get double integer parameter.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setIntParameter(std::string const &paramName, int const value, std::string const &docString, ParameterList *paramList, AnyNumberParameterEntryValidator::AcceptedTypes const &acceptedTypes=AnyNumberParameterEntryValidator::AcceptedTypes())
Set an integer parameter that allows for (nearly) any input parameter type that is convertible to an ...
T & get(const std::string &name, T def_value)
Return the parameter's value, or the default value if it is not there.
std::string getStringValue(ParameterList const &paramList, std::string const &paramName)
Get a std::string value for a parameter that is assumed to already be set.
void setStringToIntegralParameter(std::string const &paramName, std::string const &defaultValue, std::string const &docString, ArrayView< const std::string > const &strings, ParameterList *paramList)
Set up a std::string parameter that will use an embedded validator to allow the extraction of an inte...
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void setNumericStringParameter(std::string const &paramName, std::string const &value, std::string const &docString, ParameterList *paramList, AnyNumberParameterEntryValidator::AcceptedTypes const &acceptedTypes=AnyNumberParameterEntryValidator::AcceptedTypes())
Set an numeric parameter preferred as a std::string that allows for (nearly) any input parameter type...
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT long long getLongLongParameter(ParameterList const &paramList, std::string const &paramName)
Get a long long parameter.
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT int getIntParameter(ParameterList const &paramList, std::string const &paramName)
Get an integer parameter.
Smart reference counting pointer class for automatic garbage collection.
static std::ostream & printLines(std::ostream &os, const std::string &linePrefix, const std::string &lines)
Print lines with prefix first.
Standard implementation of a ParameterEntryValidator that maps from a list of strings to an enum or i...
IntegralType getIntegralValue(const ParameterEntry &entry, const std::string &paramName="", const std::string &sublistName="", const bool activeQuery=true) const
Find the enum or integer value for the given ParameterEntry.
StringToIntegralParameterEntryValidator(const ArrayView< const std::string > &strings, const std::string &defaultParameterName, const bool caseSensitive=true)
Construct with a mapping from strings to the enum or integer values .
StringToIntegralParameterEntryValidator(const ArrayView< const std::string > &strings, const ArrayView< const std::string > &stringsDocs, const ArrayView< const IntegralType > &integralValues, const std::string &defaultParameterName, const bool caseSensitive=true)
Construct with a mapping from strings (with documentation) to specified enum or integer values,...
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.
ValidStringsList getStringDocs() const
Get a pointer to the array containing all the documentation strings.
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, std::string const &defaultParameterName, const bool caseSensitive)
Nonmember constructor (see implementation).
IntegralType getIntegralValue(ParameterList &paramList, const std::string &paramName, const std::string &defaultValue) const
Get the integer enum value for the given parameter.
StringToIntegralParameterEntryValidator(const ArrayView< const std::string > &strings, const ArrayView< const IntegralType > &integralValues, std::string const &defaultParameterName, const bool caseSensitive=true)
Construct with a mapping from strings to specified enum or integer values.
std::string validateString(const std::string &str, const std::string &paramName="", const std::string &sublistName="") const
Validate the std::string and pass it on.
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.
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, std::string const &defaultParameterName)
Nonmember constructor (see implementation).
bool isCaseSensitive() const
Whether this validator is case sensitive.
std::string getStringValue(ParameterList &paramList, const std::string &paramName, const std::string &defaultValue) const
Lookup a parameter from a parameter list, validate the std::string value, and return the std::string ...
void printDoc(std::string const &docString, std::ostream &out) const
Print documentation to the given output string.
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, ArrayView< const IntegralType > const &integralValues, std::string const &defaultParameterName)
Nonmember constructor (see implementation).
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, ArrayView< const std::string > const &stringsDocs, ArrayView< const IntegralType > const &integralValues, std::string const &defaultParameterName, const bool caseSensitive)
Nonmember constructor (see implementation).
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, ArrayView< const std::string > const &stringsDocs, ArrayView< const IntegralType > const &integralValues, std::string const &defaultParameterName)
Nonmember constructor (see implementation).
RCP< StringToIntegralParameterEntryValidator< IntegralType > > stringToIntegralParameterEntryValidator(ArrayView< const std::string > const &strings, ArrayView< const IntegralType > const &integralValues, std::string const &defaultParameterName, const bool caseSensitive)
Nonmember constructor (see implementation).
const std::string & getDefaultParameterName() const
Get the name of the default parameter for the validator.
void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
Validate the given ParameterEntry.
A simple validator that only allows certain string values to be choosen or simply enforces that a par...
Convience class for FileNameValidators that are to be applied to TwoDArrays.
TwoDArrayFileNameValidator(RCP< const FileNameValidator > prototypeValidator)
Convience class for EnhancedNumberValidators that are to be applied to TwoDArray.
TwoDArrayNumberValidator(RCP< const EnhancedNumberValidator< T > > prototypeValidator)
Convience class for StringValidators that are to be applied to TwoDArrays.
TwoDArrayStringValidator(RCP< const StringValidator > prototypeValidator)
Takes a validator, wraps it, and applies it to a TwoDArray.
virtual void validate(ParameterEntry const &entry, std::string const &paramName, std::string const &sublistName) const
TwoDArrayValidator(RCP< const ValidatorType > prototypeValidator)
Constructs a ArrayValidator.
virtual void printDoc(std::string const &docString, std::ostream &out) const
A thin wrapper around the Array class which causes it to be interpreted as a 2D Array.
size_type getNumCols() const
returns the number of columns in the TwoDArray.
size_type getNumRows() const
returns the number of rows in the TwoDArray.
Default traits class that just returns typeid(T).name().
Modified boost::any class, which is a container for a templated value.
std::string typeName() const
Return the name of the type.
const std::type_info & type() const
Return the type of value being stored.
#define TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
This macro is designed to be a short version of TEUCHOS_TEST_FOR_EXCEPTION() that is easier to call.
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
#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 ...
bool is_null(const boost::shared_ptr< T > &p)
Returns true if p.get()==NULL.
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
EVerbosityLevel
Verbosity level.
The Teuchos namespace contains all of the classes, structs and enums used by Teuchos,...
RCP< const StringToIntegralParameterEntryValidator< IntegralType > > getStringToIntegralParameterEntryValidator(ParameterEntry const &entry, ParameterList const &paramList, std::string const &paramName)
Get a StringToIntegralParameterEntryValidator<IntegralType> object out of a ParameterEntry object.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Default structure used by EnhancedNumberTraits<T> to produce a compile time error when the specializa...
static T notDefined()
This function should not compile if there is an attempt to instantiate!