Teuchos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Condition_Serialization_UnitTests.cpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Teuchos: Common Tools Package
4 //
5 // Copyright 2004 NTESS and the Teuchos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #include "Teuchos_UnitTestHarness.hpp"
11 #include "Teuchos_VerboseObject.hpp"
12 #include "Teuchos_ParameterList.hpp"
13 #include "Teuchos_StandardConditions.hpp"
14 #include "Teuchos_ConditionXMLConverterDB.hpp"
15 #include "Teuchos_StandardDependencies.hpp"
16 #include "Teuchos_XMLParameterListCoreHelpers.hpp"
17 #include "Teuchos_XMLParameterListExceptions.hpp"
18 #include "Teuchos_StandardConditionXMLConverters.hpp"
19 #include "Teuchos_XMLConditionExceptions.hpp"
20 
21 #include "Teuchos_XMLParameterListTestHelpers.hpp"
22 
23 
24 namespace Teuchos{
25 
26 
30 TEUCHOS_UNIT_TEST(Teuchos_Conditions, StringConditionSerialization){
31  ConditionXMLConverterDB::printKnownConverters(out);
32  std::string paramName1 = "string param";
33  std::string paramName2 = "string param2";
34  std::string dependent1Name = "dependent1";
35  std::string dependent2Name = "dependent2";
36  std::string paramValue = "cheese";
37  StringCondition::ValueList conditionVal1 = tuple<std::string>("steve");
38  StringCondition::ValueList conditionVal2 =
39  tuple<std::string>("steve", "blah", "your face");
40  ParameterList testList("Condition Test List");
41  testList.set(paramName1, paramValue);
42  testList.set(paramName2, paramValue);
43  testList.set(dependent1Name, paramValue);
44  testList.set(dependent2Name, paramValue);
45  RCP<StringCondition> simpleStringCon =
46  rcp(new StringCondition(testList.getEntryRCP(paramName1), conditionVal1));
47  RCP<StringCondition> complexStringCon =
48  rcp(new StringCondition(
49  testList.getEntryRCP(paramName2), conditionVal2));
50 
51  RCP<ConditionVisualDependency> simpleConDep =
52  rcp(new ConditionVisualDependency(
53  simpleStringCon,
54  testList.getEntryRCP(dependent1Name)));
55 
56  RCP<ConditionVisualDependency> complexConDep =
57  rcp(new ConditionVisualDependency(
58  complexStringCon,
59  testList.getEntryRCP(dependent2Name)));
60 
61  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
62  depSheet1->addDependency(simpleConDep);
63  depSheet1->addDependency(complexConDep);
64 
65  writeParameterListToXmlOStream(testList, out, depSheet1);
66 
67  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
68  RCP<ParameterList> readinList =
69  writeThenReadPL(testList, depSheet1, depSheetIn);
70 
71  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
72  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
73 
74  RCP<ConditionVisualDependency> simpleReadInDep =
75  rcp_dynamic_cast<ConditionVisualDependency>(
76  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
77  TEST_EQUALITY(
78  simpleReadInDep->getCondition()->getTypeAttributeValue(),
79  DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
80  RCP<const StringCondition> simpleReadInCon =
81  rcp_dynamic_cast<const StringCondition>(simpleReadInDep->getCondition(), true);
82  TEST_ASSERT(nonnull(simpleReadInCon));
83 
84 
85  RCP<ConditionVisualDependency> complexReadInDep =
86  rcp_dynamic_cast<ConditionVisualDependency>(
87  *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
88  TEST_EQUALITY(
89  complexReadInDep->getCondition()->getTypeAttributeValue(),
90  DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
91  RCP<const StringCondition> complexReadInCon =
92  rcp_dynamic_cast<const StringCondition>(complexReadInDep->getCondition(), true);
93  TEST_ASSERT(nonnull(complexReadInCon));
94 
95 
96  TEST_COMPARE_ARRAYS(
97  simpleReadInCon->getValueList(), simpleStringCon->getValueList());
98  TEST_COMPARE_ARRAYS(
99  complexReadInCon->getValueList(), complexStringCon->getValueList());
100 
101 }
102 
103 TEUCHOS_UNIT_TEST(Teuchos_Conditions, BoolConditionSerialization){
104  ConditionXMLConverterDB::printKnownConverters(out);
105  std::string paramName1 = "bool param";
106  std::string dependent1Name = "dependent1";
107  bool paramValue = true;
108  std::string dependentValue = "hi there!";
109  ParameterList testList("Condition Test List");
110  testList.set(paramName1, paramValue);
111  testList.set(dependent1Name, dependentValue);
112  RCP<BoolCondition> boolCon =
113  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
114 
115  RCP<ConditionVisualDependency> boolConDep =
116  rcp(new ConditionVisualDependency(
117  boolCon,
118  testList.getEntryRCP(dependent1Name)));
119 
120  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
121  depSheet1->addDependency(boolConDep);
122 
123  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
124  RCP<ParameterList> readinList =
125  writeThenReadPL(testList, depSheet1, depSheetIn);
126 
127  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
128 
129  RCP<ConditionVisualDependency> simpleReadInDep =
130  rcp_dynamic_cast<ConditionVisualDependency>(
131  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
132  TEST_EQUALITY(
133  simpleReadInDep->getCondition()->getTypeAttributeValue(),
134  DummyObjectGetter<BoolCondition>::getDummyObject()->getTypeAttributeValue());
135  RCP<const BoolCondition> simpleReadInCon =
136  rcp_dynamic_cast<const BoolCondition>(simpleReadInDep->getCondition(), true);
137  TEST_ASSERT(nonnull(simpleReadInCon));
138 
139 }
140 
141 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(Teuchos_Conditions, NumberConditionSerialization, T){
142  ConditionXMLConverterDB::printKnownConverters(out);
143  std::string paramName1 = "T param";
144  std::string paramName2 = "T param 2";
145  std::string dependent1Name = "dependent1";
146  std::string dependent2Name = "dependent2";
147  T paramValue = ScalarTraits< T >::one();
148  T ten = 10 * ScalarTraits< T >::one();
149  std::string dependentValue = "hi there!";
150  ParameterList testList("Condition Test List");
151  testList.set(paramName1, paramValue);
152  testList.set(paramName2, paramValue);
153  testList.set(dependent1Name, dependentValue);
154  testList.set(dependent2Name, dependentValue);
155 
156  RCP<NumberCondition< T > > numberCon =
157  rcp(new NumberCondition< T >(testList.getEntryRCP(paramName1)));
158 
159  RCP<SubtractionFunction< T > > funcTester =
160  rcp(new SubtractionFunction< T >(ten));
161 
162  RCP<NumberCondition< T > > numberFuncCon =
163  rcp(new NumberCondition< T >(testList.getEntryRCP(paramName2), funcTester));
164 
165  RCP<ConditionVisualDependency> numberConDep =
166  rcp(new ConditionVisualDependency(
167  numberCon,
168  testList.getEntryRCP(dependent1Name)));
169 
170  RCP<ConditionVisualDependency> funcNumberConDep =
171  rcp(new ConditionVisualDependency(
172  numberFuncCon,
173  testList.getEntryRCP(dependent2Name)));
174 
175  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
176  depSheet1->addDependency(numberConDep);
177  depSheet1->addDependency(funcNumberConDep);
178 
179  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
180  RCP<ParameterList> readinList =
181  writeThenReadPL(testList, depSheet1, depSheetIn);
182 
183  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
184  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
185 
186 
187 
188 
189  RCP<ConditionVisualDependency> simpleReadInDep =
190  rcp_dynamic_cast<ConditionVisualDependency>(
191  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
192  TEST_EQUALITY(
193  simpleReadInDep->getCondition()->getTypeAttributeValue(),
194  DummyObjectGetter<NumberCondition< T > >::getDummyObject()->getTypeAttributeValue());
195  RCP<const NumberCondition< T > > simpleReadInCon =
196  rcp_dynamic_cast<const NumberCondition< T > >(simpleReadInDep->getCondition(), true);
197  TEST_ASSERT(nonnull(simpleReadInCon));
198 
199 
200  RCP<ConditionVisualDependency> funcReadInDep =
201  rcp_dynamic_cast<ConditionVisualDependency>(
202  *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
203  TEST_ASSERT(funcReadInDep != null);
204 
205  RCP<const NumberCondition< T > > funcReadInCon =
206  rcp_dynamic_cast<const NumberCondition< T > >(funcReadInDep->getCondition());
207 
208  TEST_ASSERT(funcReadInCon != null);
209 
210  RCP<const SubtractionFunction< T > > funcReadInFunc =
211  rcp_dynamic_cast<const SubtractionFunction< T > >(
212  funcReadInCon->getFunctionObject());
213  TEST_ASSERT(funcReadInFunc != null);
214  TEST_EQUALITY(
215  funcReadInFunc->getModifiyingOperand(),
216  funcTester->getModifiyingOperand());
217 
218 
219 }
220 
221 #define NUMBER_PARAM_TYPE_TEST( T ) \
222 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT(Teuchos_Conditions, NumberConditionSerialization, T )
223 
224 typedef unsigned int uint;
225 typedef unsigned short ushort;
226 typedef unsigned long ulong;
227 
228 NUMBER_PARAM_TYPE_TEST(int)
229 NUMBER_PARAM_TYPE_TEST(uint)
230 NUMBER_PARAM_TYPE_TEST(short)
231 NUMBER_PARAM_TYPE_TEST(ushort)
232 NUMBER_PARAM_TYPE_TEST(long)
233 NUMBER_PARAM_TYPE_TEST(ulong)
234 NUMBER_PARAM_TYPE_TEST(float)
235 NUMBER_PARAM_TYPE_TEST(double)
236 typedef long long int llint;
237 typedef unsigned long long int ullint;
238 NUMBER_PARAM_TYPE_TEST(llint)
239 NUMBER_PARAM_TYPE_TEST(ullint)
240 
241 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(Teuchos_Conditions, BoolLogicConditionSerialization, BinCondition){
242  ConditionXMLConverterDB::printKnownConverters(out);
243  std::string paramName1 = "bool param1";
244  std::string paramName2 = "bool param2";
245  std::string dependent1Name = "dependent1";
246  bool paramValue1 = true;
247  bool paramValue2 = false;
248  std::string dependentValue = "hi there!";
249  ParameterList testList("Condition Test List");
250  testList.set(paramName1, paramValue1);
251  testList.set(paramName2, paramValue2);
252  testList.set(dependent1Name, dependentValue);
253  RCP<BoolCondition> boolCon1 =
254  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
255  RCP<BoolCondition> boolCon2 =
256  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
257 
258  Condition::ConstConditionList conList =
259  tuple<RCP<const Condition> >(boolCon1, boolCon2);
260 
261  RCP< BinCondition > binCon = rcp(new BinCondition (conList));
262 
263  RCP<ConditionVisualDependency> binConDep =
264  rcp(new ConditionVisualDependency(
265  binCon,
266  testList.getEntryRCP(dependent1Name)));
267 
268  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
269  depSheet1->addDependency(binConDep);
270 
271  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
272  RCP<ParameterList> readinList =
273  writeThenReadPL(testList, depSheet1, depSheetIn);
274 
275  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
276  RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
277 
278  RCP<ConditionVisualDependency> readInDep1 =
279  rcp_dynamic_cast<ConditionVisualDependency>(
280  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
281  RCP<ConditionVisualDependency> readInDep2 =
282  rcp_dynamic_cast<ConditionVisualDependency>(
283  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
284  TEST_EQUALITY(readInDep1.get(), readInDep1.get());
285  TEST_EQUALITY(
286  readInDep1->getCondition()->getTypeAttributeValue(),
287  DummyObjectGetter< BinCondition >::getDummyObject()->getTypeAttributeValue());
288  RCP<const BinCondition > readInCon =
289  rcp_dynamic_cast<const BinCondition >(readInDep1->getCondition(), true);
290  TEST_ASSERT(nonnull(readInCon));
291 
292  Condition::ConstConditionList readInConList = readInCon->getConditions();
293  TEST_ASSERT(readInConList.size() ==2);
294 
295 }
296 
297 #define BIN_CON_TEST( BinCondition ) \
298 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT(Teuchos_Conditions, BoolLogicConditionSerialization, BinCondition)
299 
300 BIN_CON_TEST(AndCondition)
301 BIN_CON_TEST(OrCondition)
302 BIN_CON_TEST(EqualsCondition)
303 
304 TEUCHOS_UNIT_TEST(Teuchos_Conditions, NotConditionSerialization){
305  ConditionXMLConverterDB::printKnownConverters(out);
306  std::string paramName1 = "bool param1";
307  std::string dependent1Name = "dependent1";
308  bool paramValue1 = true;
309  std::string dependentValue = "hi there!";
310  ParameterList testList("Condition Test List");
311  testList.set(paramName1, paramValue1);
312  testList.set(dependent1Name, dependentValue);
313  RCP<BoolCondition> boolCon1 =
314  rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
315 
316 
317  RCP<NotCondition> notCon = rcp(new NotCondition(boolCon1));
318 
319  RCP<ConditionVisualDependency> notConDep =
320  rcp(new ConditionVisualDependency(
321  notCon,
322  testList.getEntryRCP(dependent1Name)));
323 
324  RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
325  depSheet1->addDependency(notConDep);
326 
327  RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
328  RCP<ParameterList> readinList =
329  writeThenReadPL(testList, depSheet1, depSheetIn);
330 
331  RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
332 
333  RCP<ConditionVisualDependency> readInDep1 =
334  rcp_dynamic_cast<ConditionVisualDependency>(
335  *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
336  TEST_EQUALITY(
337  readInDep1->getCondition()->getTypeAttributeValue(),
338  DummyObjectGetter<NotCondition>::getDummyObject()->getTypeAttributeValue());
339  RCP<const NotCondition> readInCon =
340  rcp_dynamic_cast<const NotCondition>(readInDep1->getCondition(), true);
341  TEST_ASSERT(nonnull(readInCon));
342 }
343 
344 TEUCHOS_UNIT_TEST(Teuchos_Conditions, ConditionSerializationExceptions){
345  ConditionXMLConverterDB::printKnownConverters(out);
346  RCP<DependencySheet> depSheet = rcp(new DependencySheet);
347 
348 
349  TEST_THROW(RCP<ParameterList> missingParameterList =
350  getParametersFromXmlFile(
351  "MissingParameterEntryDefinition.xml", depSheet),
352  MissingParameterEntryDefinitionException);
353 
354  RCP<ParameterEntry> notInListParam = rcp(new ParameterEntry(3.0));
355  RCP<NumberCondition<double> > doubleCon =
356  rcp(new NumberCondition<double>(notInListParam));
357 
358  NumberConditionConverter<double> doubleConConverter;
359  XMLParameterListWriter::EntryIDsMap emptyMap;
360  XMLObject toWriteTo;
361  TEST_THROW(doubleConConverter.fromConditiontoXML(doubleCon, emptyMap),
362  MissingParameterEntryDefinitionException);
363 
364  TEST_THROW(RCP<ParameterList> missingValuesList =
365  getParametersFromXmlFile(
366  "MissingValuesTag.xml", depSheet),
367  MissingValuesTagException);
368 
369 
370 }
371 
372 
373 } // namespace Teuchos
Teuchos::DependencySheet
A Dependency sheet keeps track of dependencies between various ParameterEntries.
Definition: Teuchos_DependencySheet.hpp:27
Teuchos_VerboseObject.hpp
TEST_ASSERT
#define TEST_ASSERT(v1)
Assert the given statement is true.
Definition: Teuchos_LocalTestingHelpers.hpp:39
Teuchos::DummyObjectGetter::getDummyObject
static RCP< T > getDummyObject()
Retrieves a dummy object of type T.
Definition: Teuchos_DummyObjectGetter.hpp:28
Teuchos::ParameterList::getEntryRCP
RCP< ParameterEntry > getEntryRCP(const std::string &name)
Retrieves the RCP for an entry with the name name if it exists.
Definition: Teuchos_ParameterList.hpp:1160
Teuchos::ullint
unsigned long long int ullint
Definition: Condition_Serialization_UnitTests.cpp:237
Teuchos_XMLConditionExceptions.hpp
A collection of Exceptions thrown when converting Conditions to and from XML.
Teuchos::nonnull
bool nonnull(const std::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
Definition: Teuchos_RCPStdSharedPtrConversionsDecl.hpp:127
Teuchos::ParameterEntry
This object is held as the &quot;value&quot; in the Teuchos::ParameterList std::map.
Definition: Teuchos_ParameterEntry.hpp:34
Teuchos::ConditionXMLConverterDB::printKnownConverters
static void printKnownConverters(std::ostream &out)
prints the xml tags associated with all known converters
Definition: Teuchos_ConditionXMLConverterDB.hpp:107
TEST_EQUALITY
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
Definition: Teuchos_LocalTestingHelpers.hpp:55
TEST_THROW
#define TEST_THROW(code, ExceptType)
Assert that the statement &#39;code&#39; throws the exception &#39;ExceptType&#39; (otherwise the test fails)...
Definition: Teuchos_LocalTestingHelpers.hpp:179
Teuchos::NotCondition
A Not condition returns the result of performing a logical NOT on a given condition.
Definition: Teuchos_StandardConditions.hpp:719
Teuchos::RCP::get
T * get() const
Get the raw C++ pointer to the underlying object.
Definition: Teuchos_RCP.hpp:365
Teuchos::StringCondition::getValueList
const ValueList & getValueList() const
Returns the value list being used with this StringCondition.
Definition: Teuchos_StandardConditions.hpp:169
Teuchos::ParameterList::set
ParameterList & set(std::string const &name, T &&value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
Templated set method.
Definition: Teuchos_ParameterList.hpp:934
Teuchos::NumberCondition
A Number Condition is a Parameter Condition that evaluates whether or not a number parameter is great...
Definition: Teuchos_StandardConditions.hpp:227
Teuchos_XMLParameterListCoreHelpers.hpp
Simple helper functions that make it easy to read and write XML to and from a parameterlist.
Teuchos::DependencySheet::addDependency
void addDependency(RCP< Dependency > dependency)
Adds a dependency to the sheet.
Definition: Teuchos_DependencySheet.cpp:24
Teuchos::MissingParameterEntryDefinitionException
Thrown when a referenced ParameterEntry can&#39;t be found.
Definition: Teuchos_XMLParameterListExceptions.hpp:207
Teuchos::SubtractionFunction
A simple function object that subtracts a specififed value from the given arguement in the runFunctio...
Definition: Teuchos_StandardFunctionObjects.hpp:105
Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL
TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(RCPNodeHandle, basicConstruct_owns_mem, T)
Definition: RCPNodeHandle_UnitTests.cpp:289
Teuchos::TEUCHOS_UNIT_TEST
TEUCHOS_UNIT_TEST(ConstNonconstObjectContainer, create)
Definition: ConstNonconstObjectContainer.cpp:16
Teuchos::MissingValuesTagException
Thrown when a StringConditon is missing it&#39;s Value tag.
Definition: Teuchos_XMLConditionExceptions.hpp:24
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
Definition: Teuchos_RCPDecl.hpp:1234
Teuchos_ParameterList.hpp
Templated Parameter List class.
BIN_CON_TEST
#define BIN_CON_TEST(BinCondition)
Definition: Condition_Serialization_UnitTests.cpp:297
Teuchos::XMLObject
Representation of an XML data tree. XMLObject is a ref-counted handle to a XMLObjectImplem object...
Definition: Teuchos_XMLObject.hpp:30
Teuchos_ConditionXMLConverterDB.hpp
A database for ConditionXMLConverters.
Teuchos::StringCondition
A String Condition is a Parameter Condition that evaluates whether or not a string parameter has take...
Definition: Teuchos_StandardConditions.hpp:111
Teuchos::XMLParameterListWriter::EntryIDsMap
std::map< RCP< const ParameterEntry >, ParameterEntry::ParameterEntryID, RCPConstComp > EntryIDsMap
Definition: Teuchos_XMLParameterListWriter.hpp:41
Teuchos_UnitTestHarness.hpp
Unit testing support.
Teuchos::NumberConditionConverter
An xml converter for NumberConditions The valid XML represntation for a NumberCondition is: ...
Definition: Teuchos_StandardConditionXMLConverters.hpp:321
Teuchos_XMLParameterListTestHelpers.hpp
Teuchos::ParameterList
A list of parameters of arbitrary type.
Definition: Teuchos_ParameterList.hpp:101
Teuchos_StandardDependencies.hpp
A collection of standard dependencies.
NUMBER_PARAM_TYPE_TEST
#define NUMBER_PARAM_TYPE_TEST(T)
Definition: Condition_Serialization_UnitTests.cpp:221
Teuchos::BoolCondition
A Bool Condition is a Parameter Condition that evaluates whether or not a Boolean parameter is ture...
Definition: Teuchos_StandardConditions.hpp:341
Teuchos::ConditionVisualDependency::getCondition
RCP< const Condition > getCondition() const
Gets the condition being used in this dependency.
Definition: Teuchos_StandardDependencies.cpp:223
TEST_COMPARE_ARRAYS
#define TEST_COMPARE_ARRAYS(a1, a2)
Assert that a1.size()==a2.size() and a[i]==b[i], i=0....
Definition: Teuchos_LocalTestingHelpers.hpp:140
Teuchos::DummyObjectGetter
Class for retrieving a dummy object of type T.
Definition: Teuchos_DummyObjectGetter.hpp:23
Teuchos_XMLParameterListExceptions.hpp
A collection of Exceptions that can be potentially thrown when converting a ParameterList to and from...
Teuchos::Array::size
size_type size() const
Definition: Teuchos_Array.hpp:1006
Teuchos::ConditionXMLConverter::fromConditiontoXML
XMLObject fromConditiontoXML(const RCP< const Condition > condition, const XMLParameterListWriter::EntryIDsMap &entryIDsMap) const
Converters a given ParameterEntryValidator to XML.
Definition: Teuchos_ConditionXMLConverter.cpp:24
Teuchos::RCP
Smart reference counting pointer class for automatic garbage collection.
Definition: Teuchos_RCPDecl.hpp:397
Teuchos::ConditionVisualDependency
A condition visual dependency says the following about the relationship between elements in a Paramet...
Definition: Teuchos_StandardDependencies.hpp:495
Teuchos_StandardConditionXMLConverters.hpp
A collection of standard ConditionXMLConverters.
Teuchos::writeThenReadPL
TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< ParameterList > writeThenReadPL(ParameterList &myList)
Write a parameter list to xml and then read that xml back in via a string. The intent of this functio...
Definition: Teuchos_XMLParameterListTestHelpers.cpp:15
Teuchos::ScalarTraits::one
static T one()
Returns representation of one for this scalar type.
Definition: Teuchos_ScalarTraitsDecl.hpp:104
Teuchos_StandardConditions.hpp
Standard Conditions to be used.
Teuchos::DependencySheet::getDependenciesForParameter
RCP< const DepSet > getDependenciesForParameter(RCP< const ParameterEntry > dependee) const
Returns a set of all the dependencies associated with a particular dependee. If no dependencies with ...
Definition: Teuchos_DependencySheet.cpp:48
Generated on Thu Oct 24 2024 09:22:08 for Teuchos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5