Loading [MathJax]/extensions/TeX/newcommand.js
 deal.II version GIT relicensing-3057-gb5b616642a 2025-04-10 20:30:00+00:00
\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}} \newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=} \newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]} \newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
tria_iterator.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 1998 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_tria_iterator_h
16#define dealii_tria_iterator_h
17
18
19#include <deal.II/base/config.h>
20
22#include <deal.II/base/point.h>
24
26
27#include <iterator>
28#include <ostream>
29
31
32// Forward declarations
33#ifndef DOXYGEN
34template <int dim, int spacedim>
36class Triangulation;
37template <int, int, int>
39
40template <typename>
41class TriaIterator;
42template <typename>
44#endif
45
46
47
219template <typename Accessor>
221{
222public:
228 using AccessorType = Accessor;
229
235
240
253 explicit TriaRawIterator(const Accessor &a);
254
259 template <typename OtherAccessor>
260 explicit TriaRawIterator(const OtherAccessor &a);
261
269 const int level,
270 const int index,
271 const typename AccessorType::AccessorData *local_data = nullptr);
272
282 template <typename OtherAccessor>
284
291 const TriaAccessorBase<Accessor::structure_dimension,
292 Accessor::dimension,
293 Accessor::space_dimension> &tria_accessor,
294 const typename Accessor::AccessorData *local_data);
295
300 template <typename OtherAccessor>
302
307 template <typename OtherAccessor>
309
327 Accessor
328 operator*() const;
329
337 const Accessor *
338 operator->() const;
339
343 Accessor *
344 operator->();
345
346
356 const Accessor &
357 access_any() const;
358
366
370 template <typename OtherAccessor = Accessor>
371 std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
373
377 bool
379
405 bool
406 operator<(const TriaRawIterator &) const;
407
412 bool
413 operator>(const TriaRawIterator &) const;
414
425 operator++();
426
440
446 operator--();
447
464 state() const;
465
470 template <typename StreamType>
471 void
472 print(StreamType &out) const;
473
474
479 std::size_t
480 memory_consumption() const;
481
487 using iterator_category = std::bidirectional_iterator_tag;
488 using value_type = Accessor;
490 using pointer = Accessor *;
491 using reference = Accessor &;
492
501 Accessor,
502 << "You tried to dereference a cell iterator for which this "
503 << "is not possible. More information on this iterator: "
504 << "level=" << arg1.level() << ", index=" << arg1.index()
505 << ", state="
506 << (arg1.state() == IteratorState::valid ?
507 "valid" :
508 (arg1.state() == IteratorState::past_the_end ?
509 "past_the_end" :
510 "invalid")));
511
516 Accessor,
517 << "You tried to dereference an iterator for which this "
518 << "is not possible. More information on this iterator: "
519 << "index=" << arg1.index() << ", state="
520 << (arg1.state() == IteratorState::valid ?
521 "valid" :
522 (arg1.state() == IteratorState::past_the_end ?
523 "past_the_end" :
524 "invalid")));
525
534
536protected:
540 Accessor accessor;
541
542
543 // Make all other iterator class templates friends of this class. This is
544 // necessary for the implementation of conversion constructors.
545 //
546 // In fact, we would not need them to be friends if they were for different
547 // dimensions, but the compiler dislikes giving a fixed dimension and
548 // variable accessor since then it says that would be a partial
549 // specialization.
550 template <typename SomeAccessor>
551 friend class TriaRawIterator;
552 template <typename SomeAccessor>
553 friend class TriaIterator;
554 template <typename SomeAccessor>
555 friend class TriaActiveIterator;
556};
557
558
566template <typename Accessor>
567class TriaIterator : public TriaRawIterator<Accessor>
568{
569public:
575
580
591
603 const int level,
604 const int index,
605 const typename Accessor::AccessorData *local_data = nullptr);
606
611 template <typename OtherAccessor>
612 explicit TriaIterator(const OtherAccessor &a);
613
623 template <typename OtherAccessor>
625
631 TriaIterator(const TriaAccessorBase<Accessor::structure_dimension,
632 Accessor::dimension,
633 Accessor::space_dimension> &tria_accessor,
634 const typename Accessor::AccessorData *local_data);
635
641 template <typename OtherAccessor>
643
648 template <typename OtherAccessor>
650
656
663
668 template <class OtherAccessor>
671
677 template <class OtherAccessor>
680
692
704
711
730
735};
736
737
747template <typename Accessor>
748class TriaActiveIterator : public TriaIterator<Accessor>
749{
750public:
756
761
772
783
795 const int level,
796 const int index,
797 const typename Accessor::AccessorData *local_data = nullptr);
798
808 template <typename OtherAccessor>
810
817 const TriaAccessorBase<Accessor::structure_dimension,
818 Accessor::dimension,
819 Accessor::space_dimension> &tria_accessor,
820 const typename Accessor::AccessorData *local_data);
821
833 template <typename OtherAccessor>
835
841
848
855
860 template <class OtherAccessor>
863
869 template <class OtherAccessor>
872
878 template <class OtherAccessor>
881
889
905
912
930
935};
936
937
938/*----------------------- Inline functions -------------------*/
939
940
941template <typename Accessor>
943 : accessor(a)
944{}
945
946
947
948template <typename Accessor>
949template <typename OtherAccessor>
950inline TriaRawIterator<Accessor>::TriaRawIterator(const OtherAccessor &a)
951 : accessor(a)
952{}
953
954
955
956template <typename Accessor>
957template <typename OtherAccessor>
960 : accessor(i.accessor)
961{}
962
963
964
965template <typename Accessor>
966template <typename OtherAccessor>
969 : accessor(i.accessor)
970{}
971
972
973
974template <typename Accessor>
975template <typename OtherAccessor>
978 : accessor(i.accessor)
979{}
980
981
982
983template <typename Accessor>
984inline Accessor
986{
987 Assert(Accessor::structure_dimension != Accessor::dimension ||
988 state() == IteratorState::valid,
989 ExcDereferenceInvalidCell(accessor));
990 Assert(Accessor::structure_dimension == Accessor::dimension ||
991 state() == IteratorState::valid,
992 ExcDereferenceInvalidObject(accessor));
993
994 return accessor;
995}
996
997
998
999template <typename Accessor>
1000inline const Accessor &
1002{
1003 return accessor;
1004}
1005
1006
1007
1008template <typename Accessor>
1009inline const Accessor *
1011{
1012 return &accessor;
1013}
1014
1015
1016
1017template <typename Accessor>
1018inline Accessor *
1020{
1021 return &accessor;
1022}
1023
1024
1025
1026template <typename Accessor>
1029{
1030 return accessor.state();
1031}
1032
1033
1034
1035template <typename Accessor>
1036inline bool
1038 const TriaRawIterator<Accessor> &other) const
1039{
1040 Assert(state() != IteratorState::invalid,
1041 ExcDereferenceInvalidObject(accessor));
1043 ExcDereferenceInvalidObject(other.accessor));
1044
1045 Assert(&accessor.get_triangulation() == &other.accessor.get_triangulation(),
1046 ExcInvalidComparison());
1047
1048 // Deal with iterators past end
1049 if (state() == IteratorState::past_the_end)
1050 return false;
1051 if (other.state() == IteratorState::past_the_end)
1052 return true;
1053
1054 return ((**this) < (*other));
1055}
1056
1057
1058
1059template <typename Accessor>
1060inline bool
1062 const TriaRawIterator<Accessor> &other) const
1063{
1064 return (other < *this);
1065}
1066
1067
1068
1069template <typename Accessor>
1072{
1073 Assert(state() == IteratorState::valid, ExcAdvanceInvalidObject());
1074
1075 ++accessor;
1076 return *this;
1077}
1078
1079
1080
1081template <typename Accessor>
1084{
1085 Assert(state() == IteratorState::valid, ExcAdvanceInvalidObject());
1086
1087 --accessor;
1088 return *this;
1089}
1090
1091
1092
1093template <typename Accessor>
1094template <typename StreamType>
1095inline void
1097{
1098 if (Accessor::structure_dimension == Accessor::dimension)
1099 out << accessor.level() << '.' << accessor.index();
1100 else
1101 out << accessor.index();
1102}
1103
1104
1105
1106template <typename Accessor>
1107inline std::size_t
1112
1113
1114
1115template <typename Accessor>
1116template <typename OtherAccessor>
1119 : TriaRawIterator<Accessor>(i.accessor)
1120{}
1121
1122
1123
1124template <typename Accessor>
1125template <typename OtherAccessor>
1128 : TriaRawIterator<Accessor>(i.accessor)
1129{}
1130
1131
1132
1133template <typename Accessor>
1134template <typename OtherAccessor>
1137 : TriaRawIterator<Accessor>(i.accessor)
1138{
1139 if constexpr (running_in_debug_mode())
1140 {
1141 // do this like this, because:
1142 // if we write
1143 // "Assert (IteratorState::past_the_end || used)"
1144 // used() is called anyway, even if
1145 // state==IteratorState::past_the_end, and will then
1146 // throw the exception!
1147 if (this->state() != IteratorState::past_the_end)
1149 }
1150}
1151
1152template <typename Accessor>
1153template <typename OtherAccessor>
1155 : TriaRawIterator<Accessor>(a)
1156{
1157 if constexpr (running_in_debug_mode())
1158 {
1159 // do this like this, because:
1160 // if we write
1161 // "Assert (IteratorState::past_the_end || used)"
1162 // used() is called anyway, even if
1163 // state==IteratorState::past_the_end, and will then
1164 // throw the exception!
1165 if (this->state() != IteratorState::past_the_end)
1167 }
1168}
1169
1170template <typename Accessor>
1171template <typename OtherAccessor>
1176
1177
1178
1179template <typename Accessor>
1180template <typename OtherAccessor>
1183 : TriaIterator<Accessor>(i)
1184{
1185 if constexpr (running_in_debug_mode())
1186 {
1187 // do this like this, because:
1188 // if we write
1189 // "Assert (IteratorState::past_the_end || !has_children())"
1190 // has_children() is called anyway, even if
1191 // state==IteratorState::past_the_end, and will then
1192 // throw the exception!
1193 if (this->state() != IteratorState::past_the_end)
1194 Assert(this->accessor.has_children() == false,
1196 }
1197}
1198
1199
1200
1206template <typename Accessor>
1207inline std::ostream &
1208operator<<(std::ostream &out, const TriaRawIterator<Accessor> &i)
1209{
1210 i.print(out);
1211 return out;
1212}
1213
1214
1215
1221template <typename Accessor>
1222inline std::ostream &
1223operator<<(std::ostream &out, const TriaIterator<Accessor> &i)
1224{
1225 i.print(out);
1226 return out;
1227}
1228
1229
1230
1236template <typename Accessor>
1237inline std::ostream &
1238operator<<(std::ostream &out, const TriaActiveIterator<Accessor> &i)
1239{
1240 i.print(out);
1241 return out;
1242}
1243
1244
1245#ifndef DOXYGEN
1246
1247/*------------------------ Functions: TriaRawIterator ------------------*/
1248
1249
1250template <typename Accessor>
1252 : accessor(nullptr, -2, -2, nullptr)
1253{}
1254
1255
1256template <typename Accessor>
1259 : accessor(i.accessor)
1260{}
1261
1262
1263
1264template <typename Accessor>
1267 const int level,
1268 const int index,
1269 const typename Accessor::AccessorData *local_data)
1270 : accessor(parent, level, index, local_data)
1271{}
1272
1273
1274template <typename Accessor>
1276 const TriaAccessorBase<Accessor::structure_dimension,
1277 Accessor::dimension,
1278 Accessor::space_dimension> &tria_accessor,
1279 const typename Accessor::AccessorData *local_data)
1280 : accessor(nullptr, -2, -2, local_data)
1281{
1282 accessor.copy_from(tria_accessor);
1283}
1284
1285
1286template <typename Accessor>
1289{
1290 accessor.copy_from(i.accessor);
1291
1292 return *this;
1293}
1294
1295
1296
1297template <typename Accessor>
1298template <typename OtherAccessor>
1299inline std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
1301 const TriaRawIterator<OtherAccessor> &other) const
1302{
1303 return accessor == other.accessor;
1304}
1305
1306
1307template <typename Accessor>
1308inline bool
1310 const TriaRawIterator<Accessor> &other) const
1311{
1312 return !(*this == other);
1313}
1314
1315
1316template <typename Accessor>
1319{
1320 TriaRawIterator<Accessor> tmp(*this);
1321 operator++();
1322
1323 return tmp;
1324}
1325
1326
1327template <typename Accessor>
1330{
1331 TriaRawIterator<Accessor> tmp(*this);
1332 operator--();
1333
1334 return tmp;
1335}
1336
1337
1338/*----------------------- functions: TriaIterator ---------------*/
1339
1340
1341template <typename Accessor>
1343 : TriaRawIterator<Accessor>()
1344{}
1345
1346
1347template <typename Accessor>
1349 : TriaRawIterator<Accessor>(i.accessor)
1350{}
1351
1352
1353template <typename Accessor>
1355 : TriaRawIterator<Accessor>(i.accessor)
1356{
1357 if constexpr (running_in_debug_mode())
1358 {
1359 // do this like this, because:
1360 // if we write
1361 // "Assert (IteratorState::past_the_end || used)"
1362 // used() is called anyway, even if
1363 // state==IteratorState::past_the_end, and will then
1364 // throw the exception!
1365 if (this->state() != IteratorState::past_the_end)
1366 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1367 }
1368}
1369
1370
1371template <typename Accessor>
1374 const int level,
1375 const int index,
1376 const typename Accessor::AccessorData *local_data)
1377 : TriaRawIterator<Accessor>(parent, level, index, local_data)
1378{
1379 if constexpr (running_in_debug_mode())
1380 {
1381 // do this like this, because:
1382 // if we write
1383 // "Assert (IteratorState::past_the_end || used)"
1384 // used() is called anyway, even if
1385 // state==IteratorState::past_the_end, and will then
1386 // throw the exception!
1387 if (this->state() != IteratorState::past_the_end)
1388 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1389 }
1390}
1391
1392
1393template <typename Accessor>
1395 const TriaAccessorBase<Accessor::structure_dimension,
1396 Accessor::dimension,
1397 Accessor::space_dimension> &tria_accessor,
1398 const typename Accessor::AccessorData *local_data)
1399 : TriaRawIterator<Accessor>(tria_accessor, local_data)
1400{
1401 if constexpr (running_in_debug_mode())
1402 {
1403 // do this like this, because:
1404 // if we write
1405 // "Assert (IteratorState::past_the_end || used)"
1406 // used() is called anyway, even if
1407 // state==IteratorState::past_the_end, and will then
1408 // throw the exception!
1409 if (this->state() != IteratorState::past_the_end)
1410 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1411 }
1412}
1413
1414
1415template <typename Accessor>
1418{
1419 this->accessor.copy_from(i.accessor);
1420 return *this;
1421}
1422
1423
1424template <typename Accessor>
1425template <typename OtherAccessor>
1428{
1429 this->accessor.copy_from(i.accessor);
1430 return *this;
1431}
1432
1433
1434template <typename Accessor>
1437{
1438 this->accessor.copy_from(i.accessor);
1439 if constexpr (running_in_debug_mode())
1440 {
1441 // do this like this, because:
1442 // if we write
1443 // "Assert (IteratorState::past_the_end || used)"
1444 // used() is called anyway, even if
1445 // state==IteratorState::past_the_end, and will then
1446 // throw the exception!
1447 if (this->state() != IteratorState::past_the_end)
1448 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1449 }
1450 return *this;
1451}
1452
1453
1454template <typename Accessor>
1455template <typename OtherAccessor>
1458{
1459 this->accessor.copy_from(i.accessor);
1460 if constexpr (running_in_debug_mode())
1461 {
1462 // do this like this, because:
1463 // if we write
1464 // "Assert (IteratorState::past_the_end || used)"
1465 // used() is called anyway, even if
1466 // state==IteratorState::past_the_end, and will then
1467 // throw the exception!
1468 if (this->state() != IteratorState::past_the_end)
1469 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1470 }
1471 return *this;
1472}
1473
1474
1475template <typename Accessor>
1478{
1480 (this->state() == IteratorState::valid))
1481 if (this->accessor.used() == true)
1482 return *this;
1483 return *this;
1484}
1485
1486
1487template <typename Accessor>
1490{
1491 TriaIterator<Accessor> tmp(*this);
1492 operator++();
1493
1494 return tmp;
1495}
1496
1497
1498template <typename Accessor>
1501{
1503 (this->state() == IteratorState::valid))
1504 if (this->accessor.used() == true)
1505 return *this;
1506 return *this;
1507}
1508
1509
1510template <typename Accessor>
1513{
1514 TriaIterator<Accessor> tmp(*this);
1515 operator--();
1516
1517 return tmp;
1518}
1519
1520
1521/*----------------------- functions: TriaActiveIterator ---------------*/
1522
1523
1524template <typename Accessor>
1526 : TriaIterator<Accessor>()
1527{}
1528
1529
1530template <typename Accessor>
1533 : TriaIterator<Accessor>(static_cast<TriaIterator<Accessor>>(i))
1534{}
1535
1536
1537template <typename Accessor>
1540 : TriaIterator<Accessor>(i)
1541{
1542 if constexpr (running_in_debug_mode())
1543 {
1544 // do this like this, because:
1545 // if we write
1546 // "Assert (IteratorState::past_the_end || !has_children())"
1547 // has_children() is called anyway, even if
1548 // state==IteratorState::past_the_end, and will then
1549 // throw the exception!
1550 if (this->state() != IteratorState::past_the_end)
1551 Assert(this->accessor.has_children() == false,
1552 ExcAssignmentOfInactiveObject());
1553 }
1554}
1555
1556
1557template <typename Accessor>
1559 const TriaIterator<Accessor> &i)
1560 : TriaIterator<Accessor>(i)
1561{
1562 if constexpr (running_in_debug_mode())
1563 {
1564 // do this like this, because:
1565 // if we write
1566 // "Assert (IteratorState::past_the_end || !has_children())"
1567 // has_children() is called anyway, even if
1568 // state==IteratorState::past_the_end, and will then
1569 // throw the exception!
1570 if (this->state() != IteratorState::past_the_end)
1571 Assert(this->accessor.has_children() == false,
1572 ExcAssignmentOfInactiveObject());
1573 }
1574}
1575
1576
1577template <typename Accessor>
1580 const int level,
1581 const int index,
1582 const typename Accessor::AccessorData *local_data)
1583 : TriaIterator<Accessor>(parent, level, index, local_data)
1584{
1585 if constexpr (running_in_debug_mode())
1586 {
1587 // do this like this, because:
1588 // if we write
1589 // "Assert (IteratorState::past_the_end || !has_children())"
1590 // has_children() is called anyway, even if
1591 // state==IteratorState::past_the_end, and will then
1592 // throw the exception!
1593 if (this->state() != IteratorState::past_the_end)
1594 Assert(this->accessor.has_children() == false,
1595 ExcAssignmentOfInactiveObject());
1596 }
1597}
1598
1599
1600template <typename Accessor>
1602 const TriaAccessorBase<Accessor::structure_dimension,
1603 Accessor::dimension,
1604 Accessor::space_dimension> &tria_accessor,
1605 const typename Accessor::AccessorData *local_data)
1606 : TriaIterator<Accessor>(tria_accessor, local_data)
1607{
1608 if constexpr (running_in_debug_mode())
1609 {
1610 // do this like this, because:
1611 // if we write
1612 // "Assert (IteratorState::past_the_end || !has_children())"
1613 // has_children() is called anyway, even if
1614 // state==IteratorState::past_the_end, and will then
1615 // throw the exception!
1616 if (this->state() != IteratorState::past_the_end)
1617 Assert(this->accessor.has_children() == false,
1618 ExcAssignmentOfInactiveObject());
1619 }
1620}
1621
1622
1623template <typename Accessor>
1626{
1627 this->accessor.copy_from(i.accessor);
1628 return *this;
1629}
1630
1631
1632template <typename Accessor>
1633template <class OtherAccessor>
1637{
1638 this->accessor.copy_from(i.accessor);
1639 return *this;
1640}
1641
1642
1643template <typename Accessor>
1646{
1647 this->accessor.copy_from(i.accessor);
1648 if constexpr (running_in_debug_mode())
1649 {
1650 // do this like this, because:
1651 // if we write
1652 // "Assert (IteratorState::past_the_end || !has_children())"
1653 // has_children() is called anyway, even if
1654 // state==IteratorState::past_the_end, and will then
1655 // throw the exception!
1656 if (this->state() != IteratorState::past_the_end)
1657 Assert(this->accessor.used() && this->accessor.has_children() == false,
1658 ExcAssignmentOfInactiveObject());
1659 }
1660 return *this;
1661}
1662
1663
1664template <typename Accessor>
1665template <class OtherAccessor>
1668{
1669 this->accessor.copy_from(i.accessor);
1670 if constexpr (running_in_debug_mode())
1671 {
1672 // do this like this, because:
1673 // if we write
1674 // "Assert (IteratorState::past_the_end || !has_children())"
1675 // has_children() is called anyway, even if
1676 // state==IteratorState::past_the_end, and will then
1677 // throw the exception!
1678 if (this->state() != IteratorState::past_the_end)
1679 Assert(this->accessor.used() && this->accessor.has_children() == false,
1680 ExcAssignmentOfInactiveObject());
1681 }
1682 return *this;
1683}
1684
1685
1686template <typename Accessor>
1687template <class OtherAccessor>
1690{
1691 this->accessor.copy_from(i.accessor);
1692 if constexpr (running_in_debug_mode())
1693 {
1694 // do this like this, because:
1695 // if we write
1696 // "Assert (IteratorState::past_the_end || !has_children())"
1697 // has_children() is called anyway, even if
1698 // state==IteratorState::past_the_end, and will then
1699 // throw the exception!
1700 if (this->state() != IteratorState::past_the_end)
1701 Assert(this->accessor.has_children() == false,
1702 ExcAssignmentOfInactiveObject());
1703 }
1704 return *this;
1705}
1706
1707
1708template <typename Accessor>
1711{
1712 this->accessor.copy_from(i.accessor);
1713 if constexpr (running_in_debug_mode())
1714 {
1715 // do this like this, because:
1716 // if we write
1717 // "Assert (IteratorState::past_the_end || !has_children())"
1718 // has_children() is called anyway, even if
1719 // state==IteratorState::past_the_end, and will then
1720 // throw the exception!
1721 if (this->state() != IteratorState::past_the_end)
1722 Assert(this->accessor.has_children() == false,
1723 ExcAssignmentOfInactiveObject());
1724 }
1725 return *this;
1726}
1727
1728
1729template <typename Accessor>
1732{
1734 (this->state() == IteratorState::valid))
1735 if (this->accessor.has_children() == false)
1736 return *this;
1737 return *this;
1738}
1739
1740
1741template <typename Accessor>
1744{
1746 operator++();
1747
1748 return tmp;
1749}
1750
1751
1752template <typename Accessor>
1755{
1757 (this->state() == IteratorState::valid))
1758 if (this->accessor.has_children() == false)
1759 return *this;
1760 return *this;
1761}
1762
1763
1764template <typename Accessor>
1767{
1769 operator--();
1770
1771 return tmp;
1772}
1773
1774#endif
1775
1777
1778#endif
TriaActiveIterator< Accessor > & operator=(const TriaIterator< OtherAccessor > &)
TriaActiveIterator(const TriaActiveIterator< Accessor > &)
typename TriaIterator< Accessor >::reference reference
TriaActiveIterator< Accessor > & operator=(const TriaRawIterator< Accessor > &)
TriaActiveIterator< Accessor > operator--(int)
TriaActiveIterator(const TriaRawIterator< Accessor > &)
TriaActiveIterator< Accessor > & operator=(const TriaActiveIterator< Accessor > &)
typename TriaIterator< Accessor >::difference_type difference_type
typename TriaIterator< Accessor >::pointer pointer
TriaActiveIterator< Accessor > & operator=(const TriaActiveIterator< OtherAccessor > &)
TriaActiveIterator< Accessor > & operator--()
TriaActiveIterator(const TriaAccessorBase< Accessor::structure_dimension, Accessor::dimension, Accessor::space_dimension > &tria_accessor, const typename Accessor::AccessorData *local_data)
TriaActiveIterator< Accessor > & operator=(const TriaIterator< Accessor > &)
TriaActiveIterator(const Triangulation< Accessor::dimension, Accessor::space_dimension > *parent, const int level, const int index, const typename Accessor::AccessorData *local_data=nullptr)
TriaActiveIterator< Accessor > & operator++()
TriaActiveIterator< Accessor > & operator=(const TriaRawIterator< OtherAccessor > &)
typename TriaIterator< Accessor >::iterator_category iterator_category
TriaActiveIterator< Accessor > operator++(int)
typename TriaIterator< Accessor >::value_type value_type
TriaActiveIterator(const TriaIterator< Accessor > &)
typename TriaRawIterator< Accessor >::pointer pointer
TriaIterator(const TriaIterator< Accessor > &)
TriaIterator< Accessor > & operator++()
TriaIterator< Accessor > operator--(int)
typename TriaRawIterator< Accessor >::iterator_category iterator_category
TriaIterator< Accessor > & operator=(const TriaRawIterator< OtherAccessor > &)
typename TriaRawIterator< Accessor >::value_type value_type
TriaIterator< Accessor > operator++(int)
TriaIterator< Accessor > & operator=(const TriaIterator< Accessor > &)
typename TriaRawIterator< Accessor >::difference_type difference_type
TriaIterator< Accessor > & operator=(const TriaRawIterator< Accessor > &)
TriaIterator(const TriaAccessorBase< Accessor::structure_dimension, Accessor::dimension, Accessor::space_dimension > &tria_accessor, const typename Accessor::AccessorData *local_data)
typename TriaRawIterator< Accessor >::reference reference
TriaIterator< Accessor > & operator--()
TriaIterator(const Triangulation< Accessor::dimension, Accessor::space_dimension > *parent, const int level, const int index, const typename Accessor::AccessorData *local_data=nullptr)
TriaIterator< Accessor > & operator=(const TriaIterator< OtherAccessor > &)
TriaIterator(const TriaRawIterator< Accessor > &)
const Accessor * operator->() const
TriaRawIterator & operator=(const TriaRawIterator &)
bool operator>(const TriaRawIterator &) const
std::size_t memory_consumption() const
TriaRawIterator(const Triangulation< Accessor::dimension, Accessor::space_dimension > *parent, const int level, const int index, const typename AccessorType::AccessorData *local_data=nullptr)
TriaRawIterator(const TriaAccessorBase< Accessor::structure_dimension, Accessor::dimension, Accessor::space_dimension > &tria_accessor, const typename Accessor::AccessorData *local_data)
bool operator<(const TriaRawIterator &) const
TriaRawIterator(const TriaRawIterator &)
Accessor * pointer
IteratorState::IteratorStates state() const
Accessor operator*() const
std::enable_if_t< std::is_convertible_v< OtherAccessor, Accessor >, bool > operator==(const TriaRawIterator< OtherAccessor > &) const
void print(StreamType &out) const
friend class TriaRawIterator
Accessor AccessorType
bool operator!=(const TriaRawIterator &) const
TriaRawIterator operator++(int)
std::bidirectional_iterator_tag iterator_category
TriaRawIterator & operator++()
const Accessor & access_any() const
Accessor & reference
TriaRawIterator & operator--()
TriaRawIterator operator--(int)
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:35
constexpr bool running_in_debug_mode()
Definition config.h:73
#define DEAL_II_CXX20_REQUIRES(condition)
Definition config.h:242
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:36
unsigned int level
Definition grid_out.cc:4635
static ::ExceptionBase & ExcAssignmentOfUnusedObject()
#define DeclException0(Exception0)
static ::ExceptionBase & ExcAssignmentOfInactiveObject()
#define Assert(cond, exc)
static ::ExceptionBase & ExcAdvanceInvalidObject()
static ::ExceptionBase & ExcInvalidComparison()
#define DeclException1(Exception1, type1, outsequence)
static ::ExceptionBase & ExcDereferenceInvalidObject(Accessor arg1)
static ::ExceptionBase & ExcDereferenceInvalidCell(Accessor arg1)
@ past_the_end
Iterator reached end of container.
@ valid
Iterator points to a valid object.
@ invalid
Iterator is invalid, probably due to an error.
SynchronousIterators< Iterators > & operator--(SynchronousIterators< Iterators > &a)
SynchronousIterators< Iterators > & operator++(SynchronousIterators< Iterators > &a)
std::ostream & operator<<(std::ostream &out, const TriaRawIterator< Accessor > &i)