PSCF v1.3
ParamComposite.h
1#ifndef UTIL_PARAM_COMPOSITE_H
2#define UTIL_PARAM_COMPOSITE_H
3
4/*
5* Util Package - C++ Utilities for Scientific Computation
6*
7* Copyright 2010 - 2017, The Regents of the University of Minnesota
8* Distributed under the terms of the GNU General Public License.
9*/
10
11#include <util/global.h>
12#include <util/param/ParamComponent.h> // base class
13#include <util/param/ScalarParam.h> // member function template
14#include <util/param/CArrayParam.h> // member function template
15#include <util/param/DArrayParam.h> // member function template
16#include <util/param/FArrayParam.h> // member function template
17#include <util/param/FSArrayParam.h> // member function template
18#include <util/param/CArray2DParam.h> // member function template
19#include <util/param/DMatrixParam.h> // member function template
20#include <util/param/DSymmMatrixParam.h> // member function template
21#include <util/archives/Serializable_includes.h>
22
23#include <vector>
24
25namespace Util
26{
27
28 class Begin;
29 class End;
30 class Blank;
31 template <class Data> class Factory;
32
91 {
92
93 public:
94
99
103 ParamComposite(const ParamComposite& other);
104
112 ParamComposite(int capacity);
113
117 virtual ~ParamComposite();
118
127 void resetParam();
128
130
131
148 virtual void readParam(std::istream &in);
149
165 virtual void readParamOptional(std::istream &in);
166
181 virtual void readParameters(std::istream &in)
182 {};
183
193 virtual void writeParam(std::ostream &out) const;
194
196
198
210 virtual void load(Serializable::IArchive &ar);
211
219 virtual void loadOptional(Serializable::IArchive &ar);
220
235 {};
236
256 virtual void save(Serializable::OArchive &ar);
257
264
266
271
272
280 void
281 readParamComposite(std::istream &in, ParamComposite &child,
282 bool next = true);
283
291 void
292 readParamCompositeOptional(std::istream &in,
293 ParamComposite &child, bool next = true);
294
304 template <typename Type>
305 ScalarParam<Type>& read(std::istream &in, const char *label,
306 Type &value);
307
317 template <typename Type>
319 readOptional(std::istream &in, const char *label, Type &value);
320
330 template <typename Type>
332 readCArray(std::istream &in, const char *label, Type *value, int n);
333
343 template <typename Type>
345 readOptionalCArray(std::istream &in, const char *label,
346 Type *value, int n);
347
357 template <typename Type>
359 readDArray(std::istream &in, const char *label,
360 DArray<Type>& array, int n);
361
371 template <typename Type>
373 readOptionalDArray(std::istream &in, const char *label,
374 DArray<Type>& array, int n);
375
384 template <typename Type, int N>
386 readFArray(std::istream &in, const char *label,
387 FArray<Type, N >& array);
388
397 template <typename Type, int N>
399 readOptionalFArray(std::istream &in, const char *label,
400 FArray<Type, N >& array);
401
411 template <typename Type, int N>
413 readFSArray(std::istream &in, const char *label,
414 FSArray<Type, N >& array, int size);
415
425 template <typename Type, int N>
427 readOptionalFSArray(std::istream &in, const char *label,
428 FSArray<Type, N >& array, int size);
429
441 template <typename Type>
443 readCArray2D(std::istream &in, const char *label,
444 Type *value, int m, int n, int np);
445
457 template <typename Type>
459 readOptionalCArray2D(std::istream &in, const char *label,
460 Type *value, int m, int n, int np);
461
472 template <typename Type>
474 readDMatrix(std::istream &in, const char *label,
475 DMatrix<Type>& matrix, int m, int n);
476
487 template <typename Type>
489 readOptionalDMatrix(std::istream &in, const char *label,
490 DMatrix<Type>& matrix, int m, int n);
491
501 template <typename Type>
503 readDSymmMatrix(std::istream &in, const char *label,
504 DMatrix<Type>& matrix, int n);
505
515 template <typename Type>
517 readOptionalDSymmMatrix(std::istream &in, const char *label,
518 DMatrix<Type>& matrix, int n);
519
528 Begin& readBegin(std::istream &in, const char* label,
529 bool isRequired = true);
530
537 End& readEnd(std::istream &in);
538
545 Blank& readBlank(std::istream &in);
546
548
557
558
566 void
568 ParamComposite &child, bool next = true);
569
580 void
582 ParamComposite &child, bool next = true);
583
597 template <typename Type>
599 const char *label, Type &value,
600 bool isRequired);
601
612 template <typename Type>
614 const char *label, Type &value);
615
626 template <typename Type>
628 loadCArray(Serializable::IArchive &ar, const char *label,
629 Type *value, int n, bool isRequired);
630
642 template <typename Type>
644 loadCArray(Serializable::IArchive &ar, const char *label,
645 Type *value, int n);
646
657 template <typename Type>
659 loadDArray(Serializable::IArchive &ar, const char *label,
660 DArray<Type>& array, int n, bool isRequired);
661
673 template <typename Type>
675 loadDArray(Serializable::IArchive &ar, const char *label,
676 DArray<Type>& array, int n);
677
687 template <typename Type, int N>
689 loadFArray(Serializable::IArchive &ar, const char *label,
690 FArray<Type, N >& array, bool isRequired);
691
702 template <typename Type, int N>
704 loadFArray(Serializable::IArchive &ar, const char *label,
705 FArray<Type, N >& array)
706 { return loadFArray<Type, N>(ar, label, array, true); }
707
718 template <typename Type, int N>
720 loadFSArray(Serializable::IArchive &ar, const char *label,
721 FSArray<Type, N >& array, int size, bool isRequired);
722
734 template <typename Type, int N>
736 loadFSArray(Serializable::IArchive &ar, const char *label,
737 FSArray<Type, N >& array, int size)
738 { return loadFSArray<Type, N>(ar, label, array, size, true); }
739
752 template <typename Type>
754 loadCArray2D(Serializable::IArchive &ar, const char *label,
755 Type *value, int m, int n, int np, bool isRequired);
756
770 template <typename Type>
772 loadCArray2D(Serializable::IArchive &ar, const char *label,
773 Type *value, int m, int n, int np);
774
786 template <typename Type>
788 loadDMatrix(Serializable::IArchive &ar, const char *label,
789 DMatrix<Type>& matrix, int m, int n, bool isRequired);
790
801 template <typename Type>
803 loadDMatrix(Serializable::IArchive &ar, const char *label,
804 DMatrix<Type>& matrix, int m, int n);
805
816 template <typename Type>
818 loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
819 DMatrix<Type>& matrix, int n, bool isRequired);
820
830 template <typename Type>
832 loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
833 DMatrix<Type>& matrix, int n);
834
836
840
841
848 void addParamComposite(ParamComposite& child, bool next = true);
849
856 Begin& addBegin(const char* label);
857
863 End& addEnd();
864
870 Blank& addBlank();
871
873
875
879 std::string className() const;
880
884 bool isRequired() const;
885
889 bool isActive() const;
890
892
893 protected:
894
900 void setClassName(const char* className);
901
909 void setIsRequired(bool isRequired);
910
918 void setIsActive(bool isActive);
919
929 void setParent(ParamComponent& param, bool next = true);
930
937 void addComponent(ParamComponent& param, bool isLeaf = true);
938
948 template <typename Type>
949 ScalarParam<Type>& add(std::istream &in, const char *label,
950 Type &value, bool isRequired = true);
951
962 template <typename Type>
964 addCArray(std::istream &in, const char *label,
965 Type *value, int n, bool isRequired = true);
966
977 template <typename Type>
979 addDArray(std::istream &in, const char *label,
980 DArray<Type>& array, int n, bool isRequired = true);
981
991 template <typename Type, int N>
993 addFArray(std::istream &in, const char *label,
994 FArray<Type, N >& array, bool isRequired = true);
995
1006 template <typename Type, int N>
1008 addFSArray(std::istream &in, const char *label,
1009 FSArray<Type, N >& array, int size,
1010 bool isRequired = true);
1011
1024 template <typename Type>
1026 addCArray2D(std::istream &in, const char *label,
1027 Type *value, int m, int n, int np,
1028 bool isRequired = true);
1029
1041 template <typename Type>
1043 addDMatrix(std::istream &in, const char *label,
1044 DMatrix<Type>& matrix, int m, int n,
1045 bool isRequired = true);
1046
1047 private:
1048
1050 std::vector<ParamComponent*> list_;
1051
1053 std::vector<bool> isLeaf_;
1054
1056 int size_;
1057
1059 std::string className_;
1060
1062 bool isRequired_;
1063
1065 bool isActive_;
1066
1075 template <typename Type>
1076 ScalarParam<Type>& read_(std::istream &in, const char *label,
1077 Type &value, bool isRequired);
1078
1089 template <typename Type>
1091 readCArray_(std::istream &in, const char *label, Type *value,
1092 int n, bool isRequired);
1093
1104 template <typename Type>
1106 readDArray_(std::istream &in, const char *label,
1107 DArray<Type>& array, int n, bool isRequired);
1108
1118 template <typename Type, int N>
1120 readFArray_(std::istream &in, const char *label,
1121 FArray<Type, N >& array, bool isRequired);
1122
1133 template <typename Type, int N>
1135 readFSArray_(std::istream &in, const char *label,
1136 FSArray<Type, N >& array, int size, bool isRequired);
1137
1152 template <typename Type>
1154 readCArray2D_(std::istream &in, const char *label,
1155 Type *value, int m, int n, int np, bool isRequired);
1156
1168 template <typename Type>
1170 readDMatrix_(std::istream &in, const char *label,
1171 DMatrix<Type>& matrix, int m, int n, bool isRequired);
1172
1183 template <typename Type>
1185 readDSymmMatrix_(std::istream &in, const char *label,
1186 DMatrix<Type>& matrix, int n, bool isRequired);
1187
1188 };
1189
1190 // Inline accessor functions
1191
1192 /*
1193 * Get class name string.
1194 */
1195 inline std::string ParamComposite::className() const
1196 { return className_; }
1197
1198 /*
1199 * Is this ParamComposite required in the input file?
1200 */
1201 inline bool ParamComposite::isRequired() const
1202 { return isRequired_; }
1203
1204 /*
1205 * Is this parameter active?
1206 */
1207 inline bool ParamComposite::isActive() const
1208 { return isActive_; }
1209
1210 // Function templates for scalar parameters
1211
1212 /*
1213 * Add and read a scalar parameter (private).
1214 */
1215 template <typename Type>
1217 ParamComposite::read_(std::istream &in, const char *label, Type &value,
1218 bool isRequired)
1219 {
1220 ScalarParam<Type>* ptr;
1221 ptr = new ScalarParam<Type>(label, value, isRequired);
1222 setParent(*ptr);
1223 ptr->readParam(in);
1224 addComponent(*ptr);
1225 return *ptr;
1226 }
1227
1228 /*
1229 * Add (but do not read) a scalar parameter (protected).
1230 */
1231 template <typename Type>
1232 ScalarParam<Type>&
1233 ParamComposite::add(std::istream &in, const char *label, Type &value,
1234 bool isRequired)
1235 {
1236 ScalarParam<Type>* ptr;
1237 ptr = new ScalarParam<Type>(label, value, isRequired);
1238 setParent(*ptr);
1239 addComponent(*ptr);
1240 return *ptr;
1241 }
1242
1243 /*
1244 * Add and read a required scalar parameter.
1245 */
1246 template <typename Type>
1248 ParamComposite::read(std::istream &in, const char *label, Type &value)
1249 { return read_<Type>(in, label, value, true); }
1250
1251 /*
1252 * Add and read a new optional ScalarParam < Type > object.
1253 */
1254 template <typename Type>
1255 inline ScalarParam<Type>&
1256 ParamComposite::readOptional(std::istream &in, const char *label,
1257 Type &value)
1258 { return read_<Type>(in, label, value, false); }
1259
1260 /*
1261 * Add a new ScalarParam< Type > object, and load its value from an archive.
1262 */
1263 template <typename Type>
1266 Type &value, bool isRequired)
1267 {
1268 ScalarParam<Type>* ptr;
1269 ptr = new ScalarParam<Type>(label, value, isRequired);
1270 setParent(*ptr);
1271 ptr->load(ar);
1272 addComponent(*ptr);
1273 return *ptr;
1274 }
1275
1276 /*
1277 * Add a new required ScalarParam< Type > object, and load from an archive.
1278 */
1279 template <typename Type>
1280 inline ScalarParam<Type>&
1282 Type &value)
1283 { return loadParameter<Type>(ar, label, value, true); }
1284
1285 // Templates for 1D C Arrays
1286
1287 /*
1288 * Add and read a CArrayParam associated with a built-in C-array (private).
1289 */
1290 template <typename Type>
1292 ParamComposite::readCArray_(std::istream &in, const char *label,
1293 Type *value, int n, bool isRequired)
1294 {
1295 CArrayParam<Type>* ptr;
1296 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1297 setParent(*ptr);
1298 ptr->readParam(in);
1299 addComponent(*ptr);
1300 return *ptr;
1301 }
1302
1303 /*
1304 * Add a CArrayParam built-in C-array parameter (protected).
1305 */
1306 template <typename Type>
1307 CArrayParam<Type>&
1308 ParamComposite::addCArray(std::istream &in, const char *label,
1309 Type *value, int n, bool isRequired)
1310 {
1311 CArrayParam<Type>* ptr;
1312 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1313 setParent(*ptr);
1314 addComponent(*ptr);
1315 return *ptr;
1316 }
1317
1318 /*
1319 * Add and read a required CArrayParam.
1320 */
1321 template <typename Type>
1322 inline CArrayParam<Type>&
1323 ParamComposite::readCArray(std::istream &in, const char *label,
1324 Type *value, int n)
1325 { return readCArray_<Type>(in, label, value, n, true); }
1326
1327 /*
1328 * Add and read an optional CArrayParam.
1329 */
1330 template <typename Type>
1331 inline CArrayParam<Type>&
1332 ParamComposite::readOptionalCArray(std::istream &in, const char *label,
1333 Type *value, int n)
1334 { return readCArray_<Type>(in, label, value, n, false); }
1335
1336 /*
1337 * Add and load a C array parameter.
1338 */
1339 template <typename Type>
1342 Type *value, int n, bool isRequired)
1343 {
1344 CArrayParam<Type>* ptr;
1345 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1346 setParent(*ptr);
1347 ptr->load(ar);
1348 addComponent(*ptr);
1349 return *ptr;
1350 }
1351
1352 /*
1353 * Add and load a required C array parameter.
1354 */
1355 template <typename Type>
1356 inline CArrayParam<Type>&
1358 Type *value, int n)
1359 { return loadCArray<Type>(ar, label, value, n, true); }
1360
1361 // Templates for DArray parameters
1362
1363 /*
1364 * Add and read a DArrayParam associated with a DArray<Type> (private).
1365 */
1366 template <typename Type>
1368 ParamComposite::readDArray_(std::istream &in, const char *label,
1369 DArray<Type>& array, int n, bool isRequired)
1370 {
1371 DArrayParam<Type>* ptr;
1372 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1373 setParent(*ptr);
1374 ptr->readParam(in);
1375 addComponent(*ptr);
1376 return *ptr;
1377 }
1378
1379 /*
1380 * Add a DArray<Type> DArray parameter (protected).
1381 */
1382 template <typename Type>
1383 DArrayParam<Type>&
1384 ParamComposite::addDArray(std::istream &in, const char *label,
1385 DArray<Type>& array, int n, bool isRequired)
1386 {
1387 DArrayParam<Type>* ptr;
1388 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1389 setParent(*ptr);
1390 addComponent(*ptr);
1391 return *ptr;
1392 }
1393
1394 /*
1395 * Add and read a required DArrayParam.
1396 */
1397 template <typename Type>
1398 inline
1400 ParamComposite::readDArray(std::istream &in, const char *label,
1401 DArray<Type>& array, int n)
1402 { return readDArray_<Type>(in, label, array, n, true); }
1403
1404 /*
1405 * Add and read an optional DArrayParam.
1406 */
1407 template <typename Type>
1408 inline
1410 ParamComposite::readOptionalDArray(std::istream &in, const char *label,
1411 DArray<Type>& array, int n)
1412 { return readDArray_<Type>(in, label, array, n, false); }
1413
1414 /*
1415 * Add a DArray < Type > parameter, and load its elements.
1416 */
1417 template <typename Type>
1420 DArray<Type>& array, int n, bool isRequired)
1421 {
1422 DArrayParam<Type>* ptr;
1423 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1424 setParent(*ptr);
1425 ptr->load(ar);
1426 addComponent(*ptr);
1427 return *ptr;
1428 }
1429
1430 /*
1431 * Add a required DArray < Type > parameter, and load its elements.
1432 */
1433 template <typename Type>
1434 inline DArrayParam<Type>&
1436 DArray<Type>& array, int n)
1437 { return loadDArray<Type>(ar, label, array, n, true); }
1438
1439
1440
1441 // Templates for fixed size FArray array objects.
1442
1443 /*
1444 * Add and read an FArrayParam<Type, N> fixed size array (private).
1445 */
1446 template <typename Type, int N>
1448 ParamComposite::readFArray_(std::istream &in, const char *label,
1449 FArray<Type, N>& array, bool isRequired)
1450 {
1452 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1453 setParent(*ptr);
1454 ptr->readParam(in);
1455 addComponent(*ptr);
1456 return *ptr;
1457 }
1458
1459 /*
1460 * Add a FArrayParam<Type, N> parameter (protected).
1461 */
1462 template <typename Type, int N>
1463 FArrayParam<Type, N>&
1464 ParamComposite::addFArray(std::istream &in, const char *label,
1465 FArray<Type, N>& array, bool isRequired)
1466 {
1468 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1469 setParent(*ptr);
1470 addComponent(*ptr);
1471 return *ptr;
1472 }
1473
1474 /*
1475 * Add and read a required FArray < Type, N > array parameter.
1476 */
1477 template <typename Type, int N>
1478 inline
1480 ParamComposite::readFArray(std::istream &in, const char *label,
1481 FArray<Type, N >& array)
1482 { return readFArray_<Type>(in, label, array, true); }
1483
1484 /*
1485 * Add and read an optional FArray < Type, N > array parameter.
1486 */
1487 template <typename Type, int N>
1488 inline
1490 ParamComposite::readOptionalFArray(std::istream &in, const char *label,
1491 FArray<Type, N >& array)
1492 { return readFArray_<Type>(in, label, array, false); }
1493
1494 /*
1495 * Add and load an FArray < Type, N > fixed-size array parameter.
1496 */
1497 template <typename Type, int N>
1500 FArray<Type, N >& array, bool isRequired)
1501 {
1503 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1504 setParent(*ptr);
1505 ptr->load(ar);
1506 addComponent(*ptr);
1507 return *ptr;
1508 }
1509
1510 // Templates for fixed size FSArray array objects.
1511
1512 /*
1513 * Add and read an FSArrayParam<Type, N> fixed size array (private).
1514 */
1515 template <typename Type, int N>
1517 ParamComposite::readFSArray_(std::istream &in, const char *label,
1518 FSArray<Type, N>& array, int size,
1519 bool isRequired)
1520 {
1522 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1523 setParent(*ptr);
1524 ptr->readParam(in);
1525 addComponent(*ptr);
1526 return *ptr;
1527 }
1528
1529 /*
1530 * Add a FSArrayParam<Type, N> parameter (protected).
1531 */
1532 template <typename Type, int N>
1533 FSArrayParam<Type, N>&
1534 ParamComposite::addFSArray(std::istream &in, const char *label,
1535 FSArray<Type, N>& array, int size,
1536 bool isRequired)
1537 {
1539 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1540 setParent(*ptr);
1541 addComponent(*ptr);
1542 return *ptr;
1543 }
1544
1545 /*
1546 * Add and read a required FSArray < Type, N > array parameter.
1547 */
1548 template <typename Type, int N>
1549 inline
1551 ParamComposite::readFSArray(std::istream &in, const char *label,
1552 FSArray<Type, N >& array, int size)
1553 { return readFSArray_<Type>(in, label, array, size, true); }
1554
1555 /*
1556 * Add and read an optional FSArray < Type, N > array parameter.
1557 */
1558 template <typename Type, int N>
1559 inline
1562 const char *label,
1563 FSArray<Type, N >& array,
1564 int size)
1565 { return readFSArray_<Type>(in, label, array, size, false); }
1566
1567 /*
1568 * Add and load an FSArray < Type, N > fixed-size array parameter.
1569 */
1570 template <typename Type, int N>
1573 const char *label,
1574 FSArray<Type, N >& array, int size,
1575 bool isRequired)
1576 {
1578 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1579 setParent(*ptr);
1580 ptr->load(ar);
1581 addComponent(*ptr);
1582 return *ptr;
1583 }
1584
1585 // Templates for built-in two-dimensional C Arrays
1586
1587 /*
1588 * Add and read a CArray2DParam 2D C array (private).
1589 */
1590 template <typename Type>
1592 ParamComposite::readCArray2D_(std::istream &in, const char *label,
1593 Type *value, int m, int n, int np,
1594 bool isRequired)
1595 {
1597 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1598 setParent(*ptr);
1599 ptr->readParam(in);
1600 addComponent(*ptr);
1601 return *ptr;
1602 }
1603
1604 /*
1605 * Add a CArray2DParam 2D C array (protected).
1606 */
1607 template <typename Type>
1608 CArray2DParam<Type>&
1609 ParamComposite::addCArray2D(std::istream &in, const char *label,
1610 Type *value, int m, int n, int np,
1611 bool isRequired)
1612 {
1614 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1615 setParent(*ptr);
1616 addComponent(*ptr);
1617 return *ptr;
1618 }
1619
1620 /*
1621 * Add and read a required CArray2DParam.
1622 */
1623 template <typename Type>
1624 inline CArray2DParam<Type>&
1625 ParamComposite::readCArray2D(std::istream &in, const char *label,
1626 Type *value, int m, int n, int np)
1627 { return readCArray2D_<Type>(in, label, value, m, n, np, true); }
1628
1629 /*
1630 * Add and read an optional CArray2DParam.
1631 */
1632 template <typename Type>
1633 inline CArray2DParam<Type>&
1635 const char *label, Type *value,
1636 int m, int n, int np)
1637 { return readCArray2D_<Type>(in, label, value, m, n, np, false); }
1638
1639 /*
1640 * Add and load a CArray2DParam < Type > 2D C array parameter.
1641 */
1642 template <typename Type>
1645 const char *label,
1646 Type *value, int m, int n, int np,
1647 bool isRequired)
1648 {
1650 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1651 setParent(*ptr);
1652 ptr->load(ar);
1653 addComponent(*ptr);
1654 return *ptr;
1655 }
1656
1657 /*
1658 * Add and load a required CArray2DParam < Type > 2D C array.
1659 */
1660 template <typename Type>
1663 const char *label,
1664 Type *value, int m, int n, int np)
1665 { return loadCArray2D<Type>(ar, label, value, m, n, np, true); }
1666
1667 // Templates for DMatrix containers
1668
1669 /*
1670 * Add and read a DMatrixParam DMatrix<Type> parameter (private).
1671 */
1672 template <typename Type>
1674 ParamComposite::readDMatrix_(std::istream &in, const char *label,
1675 DMatrix<Type>& matrix, int m, int n,
1676 bool isRequired)
1677 {
1678 DMatrixParam<Type>* ptr;
1679 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1680 setParent(*ptr);
1681 ptr->readParam(in);
1682 addComponent(*ptr);
1683 return *ptr;
1684 }
1685
1686 /*
1687 * Add a DMatrixParam DMatrix<Type> parameter (protected).
1688 */
1689 template <typename Type>
1690 DMatrixParam<Type>&
1691 ParamComposite::addDMatrix(std::istream &in, const char *label,
1692 DMatrix<Type>& matrix, int m, int n,
1693 bool isRequired)
1694 {
1695 DMatrixParam<Type>* ptr;
1696 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1697 setParent(*ptr);
1698 addComponent(*ptr);
1699 return *ptr;
1700 }
1701
1702 /*
1703 * Add and read a required DMatrixParam.
1704 */
1705 template <typename Type>
1706 inline DMatrixParam<Type>&
1707 ParamComposite::readDMatrix(std::istream &in, const char *label,
1708 DMatrix<Type>& matrix, int m, int n)
1709 { return readDMatrix_<Type>(in, label, matrix, m, n, true); }
1710
1711 /*
1712 * Add and read an optional DMatrixParam.
1713 */
1714 template <typename Type>
1715 inline DMatrixParam<Type>&
1716 ParamComposite::readOptionalDMatrix(std::istream &in, const char *label,
1717 DMatrix<Type>& matrix, int m, int n)
1718 { return readDMatrix_<Type>(in, label, matrix, m, n, false); }
1719
1720 /*
1721 * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
1722 */
1723 template <typename Type>
1726 DMatrix<Type>& matrix, int m, int n,
1727 bool isRequired)
1728 {
1729 DMatrixParam<Type>* ptr;
1730 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1731 setParent(*ptr);
1732 ptr->load(ar);
1733 addComponent(*ptr);
1734 return *ptr;
1735 }
1736
1737 /*
1738 * Add and load a required DMatrixParam< Type> matrix parameter.
1739 */
1740 template <typename Type>
1741 inline DMatrixParam<Type>&
1743 DMatrix<Type>& matrix, int m, int n)
1744 { return loadDMatrix<Type>(ar, label, matrix, m, n, true); }
1745
1746 // Templates for Symmetric DMatrix containers
1747
1748 /*
1749 * Add and read a symmetric DMatrixParam DMatrix (private).
1750 */
1751 template <typename Type>
1753 ParamComposite::readDSymmMatrix_(std::istream &in,
1754 const char *label,
1755 DMatrix<Type>& matrix,
1756 int n,
1757 bool isRequired)
1758 {
1760 ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
1761 setParent(*ptr);
1762 ptr->readParam(in);
1763 addComponent(*ptr);
1764 return *ptr;
1765 }
1766
1767 /*
1768 * Add and read a required DMatrixParam.
1769 */
1770 template <typename Type>
1771 inline DSymmMatrixParam<Type>&
1773 const char *label,
1774 DMatrix<Type>& matrix,
1775 int n)
1776 { return readDSymmMatrix_<Type>(in, label, matrix, n, true); }
1777
1778 /*
1779 * Add and read an optional DMatrixParam.
1780 */
1781 template <typename Type>
1784 const char *label,
1785 DMatrix<Type>& matrix,
1786 int n)
1787 { return readDMatrix_<Type>(in, label, matrix, n, false); }
1788
1789 /*
1790 * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
1791 */
1792 template <typename Type>
1795 const char *label,
1796 DMatrix<Type>& matrix,
1797 int n,
1798 bool isRequired)
1799 {
1801 ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
1802 setParent(*ptr);
1803 ptr->load(ar);
1804 addComponent(*ptr);
1805 return *ptr;
1806 }
1807
1808 /*
1809 * Add and load a required DMatrixParam< Type> matrix parameter.
1810 */
1811 template <typename Type>
1814 const char *label,
1815 DMatrix<Type>& matrix,
1816 int n)
1817 { return loadDSymmMatrix<Type>(ar, label, matrix, n, true); }
1818
1819}
1820#endif
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Beginning line of a composite parameter block.
Definition Begin.h:25
An empty line within a parameter file.
Definition Blank.h:25
A Parameter associated with a 2D built-in C array.
A Parameter associated with a 1D C array.
Definition CArrayParam.h:23
A Parameter associated with a DArray container.
Definition DArrayParam.h:27
Dynamically allocatable contiguous array template.
Definition DArray.h:32
A Parameter associated with a 2D built-in C array.
Dynamically allocated Matrix.
Definition DMatrix.h:25
A Parameter associated with a square symmetric DMatrix.
End bracket of a ParamComposite parameter block.
Definition End.h:25
A Parameter associated with a FArray container.
Definition FArrayParam.h:27
A fixed size (static) contiguous array template.
Definition FArray.h:47
A Parameter associated with a FSArray container.
A fixed capacity (static) contiguous array with a variable logical size.
Definition FSArray.h:38
Factory template.
Definition Factory.h:34
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Abstract base class for classes that input and ouput parameters to file.
ParamComponent()
Constructor.
An object that can read multiple parameters from file.
virtual void load(Serializable::IArchive &ar)
Load all parameters from an input archive.
ScalarParam< Type > & add(std::istream &in, const char *label, Type &value, bool isRequired=true)
Add a new required ScalarParam < Type > object.
virtual void loadOptional(Serializable::IArchive &ar)
Load an optional ParamComposite.
FSArrayParam< Type, N > & addFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size, bool isRequired=true)
Add (but do not read) a FSArray < Type, N > array parameter.
FSArrayParam< Type, N > & readOptionalFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size)
Add and read an optional FSArray < Type, N > array parameter.
DSymmMatrixParam< Type > & readDSymmMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int n)
Add and read a required symmetrix DMatrix.
DArrayParam< Type > & readDArray(std::istream &in, const char *label, DArray< Type > &array, int n)
Add and read a required DArray < Type > parameter.
DArrayParam< Type > & readOptionalDArray(std::istream &in, const char *label, DArray< Type > &array, int n)
Add and read an optional DArray < Type > parameter.
virtual void readParameters(std::istream &in)
Read the body of parameter block, without begin and end lines.
FArrayParam< Type, N > & readOptionalFArray(std::istream &in, const char *label, FArray< Type, N > &array)
Add and read an optional FArray < Type, N > array parameter.
ScalarParam< Type > & read(std::istream &in, const char *label, Type &value)
Add and read a new required ScalarParam < Type > object.
FArrayParam< Type, N > & loadFArray(Serializable::IArchive &ar, const char *label, FArray< Type, N > &array, bool isRequired)
Add and load an FArray < Type, N > fixed-size array parameter.
FArrayParam< Type, N > & readFArray(std::istream &in, const char *label, FArray< Type, N > &array)
Add and read a required FArray < Type, N > array parameter.
Begin & readBegin(std::istream &in, const char *label, bool isRequired=true)
Add and read a class label and opening bracket.
void addParamComposite(ParamComposite &child, bool next=true)
Add a child ParamComposite object to the format array.
void saveOptional(Serializable::OArchive &ar)
Saves isActive flag, and then calls save() iff isActive is true.
void setClassName(const char *className)
Set class name string.
void setIsRequired(bool isRequired)
Set or unset the isActive flag.
DMatrixParam< Type > & readDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n)
Add and read a required DMatrix < Type > matrix parameter.
FSArrayParam< Type, N > & readFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size)
Add and read a required FSArray < Type, N > array parameter.
void resetParam()
Resets ParamComposite to its empty state.
virtual ~ParamComposite()
Virtual destructor.
virtual void save(Serializable::OArchive &ar)
Saves all parameters to an archive.
Begin & addBegin(const char *label)
Add a Begin object representing a class name and bracket.
CArray2DParam< Type > & readCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np)
Add and read a required CArray2DParam < Type > 2D C-array.
DArrayParam< Type > & addDArray(std::istream &in, const char *label, DArray< Type > &array, int n, bool isRequired=true)
Add (but do not read) a DArray < Type > parameter.
void setIsActive(bool isActive)
Set or unset the isActive flag.
virtual void writeParam(std::ostream &out) const
Write all parameters to an output stream.
ScalarParam< Type > & readOptional(std::istream &in, const char *label, Type &value)
Add and read a new optional ScalarParam < Type > object.
void loadParamComposite(Serializable::IArchive &ar, ParamComposite &child, bool next=true)
Add and load a required child ParamComposite.
CArrayParam< Type > & addCArray(std::istream &in, const char *label, Type *value, int n, bool isRequired=true)
Add (but do not read) a required C array parameter.
CArrayParam< Type > & loadCArray(Serializable::IArchive &ar, const char *label, Type *value, int n, bool isRequired)
Add a C array parameter and load its elements.
CArrayParam< Type > & readCArray(std::istream &in, const char *label, Type *value, int n)
Add and read a required C array parameter.
virtual void readParam(std::istream &in)
Read the parameter file block.
Blank & addBlank()
Create and add a new Blank object, representing a blank line.
bool isActive() const
Is this parameter active?
FArrayParam< Type, N > & addFArray(std::istream &in, const char *label, FArray< Type, N > &array, bool isRequired=true)
Add (but do not read) a FArray < Type, N > array parameter.
ScalarParam< Type > & loadParameter(Serializable::IArchive &ar, const char *label, Type &value, bool isRequired)
Add and load a new ScalarParam < Type > object.
FSArrayParam< Type, N > & loadFSArray(Serializable::IArchive &ar, const char *label, FSArray< Type, N > &array, int size)
Add and load a required FSArray < Type > array parameter.
End & addEnd()
Add a closing bracket.
ParamComposite()
Constructor.
std::string className() const
Get class name string.
void loadParamCompositeOptional(Serializable::IArchive &ar, ParamComposite &child, bool next=true)
Add and load an optional child ParamComposite if isActive.
DMatrixParam< Type > & loadDMatrix(Serializable::IArchive &ar, const char *label, DMatrix< Type > &matrix, int m, int n, bool isRequired)
Add and load a DMatrixParam < Type > matrix parameter.
CArray2DParam< Type > & addCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np, bool isRequired=true)
Add (but do not read) a CArray2DParam < Type > 2D C-array.
Blank & readBlank(std::istream &in)
Add and read a new Blank object, representing a blank line.
CArray2DParam< Type > & loadCArray2D(Serializable::IArchive &ar, const char *label, Type *value, int m, int n, int np, bool isRequired)
Add and load a CArray2DParam < Type > C 2D array parameter.
FSArrayParam< Type, N > & loadFSArray(Serializable::IArchive &ar, const char *label, FSArray< Type, N > &array, int size, bool isRequired)
Add and load an FSArray < Type, N > array parameter.
void readParamComposite(std::istream &in, ParamComposite &child, bool next=true)
Add and read a required child ParamComposite.
DMatrixParam< Type > & addDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n, bool isRequired=true)
Add and read a required DMatrix < Type > matrix parameter.
DSymmMatrixParam< Type > & readOptionalDSymmMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int n)
Add and read an optional DMatrix matrix parameter.
CArrayParam< Type > & readOptionalCArray(std::istream &in, const char *label, Type *value, int n)
Add and read an optional C array parameter.
virtual void readParamOptional(std::istream &in)
Read optional parameter file block.
void readParamCompositeOptional(std::istream &in, ParamComposite &child, bool next=true)
Add and attempt to read an optional child ParamComposite.
DSymmMatrixParam< Type > & loadDSymmMatrix(Serializable::IArchive &ar, const char *label, DMatrix< Type > &matrix, int n, bool isRequired)
Add and load a symmetric DSymmMatrixParam < Type > matrix parameter.
End & readEnd(std::istream &in)
Add and read the closing bracket.
void setParent(ParamComponent &param, bool next=true)
Set this to the parent of a child component.
DArrayParam< Type > & loadDArray(Serializable::IArchive &ar, const char *label, DArray< Type > &array, int n, bool isRequired)
Add an load a DArray < Type > array parameter.
virtual void loadParameters(Serializable::IArchive &ar)
Load state from archive, without adding Begin and End lines.
void addComponent(ParamComponent &param, bool isLeaf=true)
Add a new ParamComponent object to the format array.
DMatrixParam< Type > & readOptionalDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n)
Add and read an optional DMatrix < Type > matrix parameter.
FArrayParam< Type, N > & loadFArray(Serializable::IArchive &ar, const char *label, FArray< Type, N > &array)
Add and load a required FArray < Type > array parameter.
CArray2DParam< Type > & readOptionalCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np)
Add and read an optional CArray2DParam < Type > 2D C-array parameter.
bool isRequired() const
Is this ParamComposite required in the input file?
virtual void readParam(std::istream &in)
Read a label and (if the label matches) a parameter value.
Definition Parameter.cpp:42
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Template for a Parameter object associated with a scalar variable.
Definition ScalarParam.h:35
BinaryFileIArchive IArchive
Type of input archive used by load method.
BinaryFileOArchive OArchive
Type of output archive used by save method.
File containing preprocessor macros for error handling.
Utility classes for scientific computation.