deal.II version GIT relicensing-2647-gce4370862c 2025-02-15 16:00: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\}}\)
Loading...
Searching...
No Matches
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#ifdef DEBUG
1140 // do this like this, because:
1141 // if we write
1142 // "Assert (IteratorState::past_the_end || used)"
1143 // used() is called anyway, even if
1144 // state==IteratorState::past_the_end, and will then
1145 // throw the exception!
1146 if (this->state() != IteratorState::past_the_end)
1148#endif
1149}
1150
1151template <typename Accessor>
1152template <typename OtherAccessor>
1154 : TriaRawIterator<Accessor>(a)
1155{
1156#ifdef DEBUG
1157 // do this like this, because:
1158 // if we write
1159 // "Assert (IteratorState::past_the_end || used)"
1160 // used() is called anyway, even if
1161 // state==IteratorState::past_the_end, and will then
1162 // throw the exception!
1163 if (this->state() != IteratorState::past_the_end)
1165#endif
1166}
1167
1168template <typename Accessor>
1169template <typename OtherAccessor>
1174
1175
1176
1177template <typename Accessor>
1178template <typename OtherAccessor>
1181 : TriaIterator<Accessor>(i)
1182{
1183#ifdef DEBUG
1184 // do this like this, because:
1185 // if we write
1186 // "Assert (IteratorState::past_the_end || !has_children())"
1187 // has_children() is called anyway, even if
1188 // state==IteratorState::past_the_end, and will then
1189 // throw the exception!
1190 if (this->state() != IteratorState::past_the_end)
1191 Assert(this->accessor.has_children() == false,
1193#endif
1194}
1195
1196
1197
1203template <typename Accessor>
1204inline std::ostream &
1205operator<<(std::ostream &out, const TriaRawIterator<Accessor> &i)
1206{
1207 i.print(out);
1208 return out;
1209}
1210
1211
1212
1218template <typename Accessor>
1219inline std::ostream &
1220operator<<(std::ostream &out, const TriaIterator<Accessor> &i)
1221{
1222 i.print(out);
1223 return out;
1224}
1225
1226
1227
1233template <typename Accessor>
1234inline std::ostream &
1235operator<<(std::ostream &out, const TriaActiveIterator<Accessor> &i)
1236{
1237 i.print(out);
1238 return out;
1239}
1240
1241
1242#ifndef DOXYGEN
1243
1244/*------------------------ Functions: TriaRawIterator ------------------*/
1245
1246
1247template <typename Accessor>
1249 : accessor(nullptr, -2, -2, nullptr)
1250{}
1251
1252
1253template <typename Accessor>
1256 : accessor(i.accessor)
1257{}
1258
1259
1260
1261template <typename Accessor>
1264 const int level,
1265 const int index,
1266 const typename Accessor::AccessorData *local_data)
1267 : accessor(parent, level, index, local_data)
1268{}
1269
1270
1271template <typename Accessor>
1273 const TriaAccessorBase<Accessor::structure_dimension,
1274 Accessor::dimension,
1275 Accessor::space_dimension> &tria_accessor,
1276 const typename Accessor::AccessorData *local_data)
1277 : accessor(nullptr, -2, -2, local_data)
1278{
1279 accessor.copy_from(tria_accessor);
1280}
1281
1282
1283template <typename Accessor>
1286{
1287 accessor.copy_from(i.accessor);
1288
1289 return *this;
1290}
1291
1292
1293
1294template <typename Accessor>
1295template <typename OtherAccessor>
1296inline std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
1298 const TriaRawIterator<OtherAccessor> &other) const
1299{
1300 return accessor == other.accessor;
1301}
1302
1303
1304template <typename Accessor>
1305inline bool
1307 const TriaRawIterator<Accessor> &other) const
1308{
1309 return !(*this == other);
1310}
1311
1312
1313template <typename Accessor>
1316{
1317 TriaRawIterator<Accessor> tmp(*this);
1318 operator++();
1319
1320 return tmp;
1321}
1322
1323
1324template <typename Accessor>
1327{
1328 TriaRawIterator<Accessor> tmp(*this);
1329 operator--();
1330
1331 return tmp;
1332}
1333
1334
1335/*----------------------- functions: TriaIterator ---------------*/
1336
1337
1338template <typename Accessor>
1340 : TriaRawIterator<Accessor>()
1341{}
1342
1343
1344template <typename Accessor>
1346 : TriaRawIterator<Accessor>(i.accessor)
1347{}
1348
1349
1350template <typename Accessor>
1352 : TriaRawIterator<Accessor>(i.accessor)
1353{
1354# ifdef DEBUG
1355 // do this like this, because:
1356 // if we write
1357 // "Assert (IteratorState::past_the_end || used)"
1358 // used() is called anyway, even if
1359 // state==IteratorState::past_the_end, and will then
1360 // throw the exception!
1361 if (this->state() != IteratorState::past_the_end)
1362 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1363# endif
1364}
1365
1366
1367template <typename Accessor>
1370 const int level,
1371 const int index,
1372 const typename Accessor::AccessorData *local_data)
1373 : TriaRawIterator<Accessor>(parent, level, index, local_data)
1374{
1375# ifdef DEBUG
1376 // do this like this, because:
1377 // if we write
1378 // "Assert (IteratorState::past_the_end || used)"
1379 // used() is called anyway, even if
1380 // state==IteratorState::past_the_end, and will then
1381 // throw the exception!
1382 if (this->state() != IteratorState::past_the_end)
1383 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1384# endif
1385}
1386
1387
1388template <typename Accessor>
1390 const TriaAccessorBase<Accessor::structure_dimension,
1391 Accessor::dimension,
1392 Accessor::space_dimension> &tria_accessor,
1393 const typename Accessor::AccessorData *local_data)
1394 : TriaRawIterator<Accessor>(tria_accessor, local_data)
1395{
1396# ifdef DEBUG
1397 // do this like this, because:
1398 // if we write
1399 // "Assert (IteratorState::past_the_end || used)"
1400 // used() is called anyway, even if
1401 // state==IteratorState::past_the_end, and will then
1402 // throw the exception!
1403 if (this->state() != IteratorState::past_the_end)
1404 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1405# endif
1406}
1407
1408
1409template <typename Accessor>
1412{
1413 this->accessor.copy_from(i.accessor);
1414 return *this;
1415}
1416
1417
1418template <typename Accessor>
1419template <typename OtherAccessor>
1422{
1423 this->accessor.copy_from(i.accessor);
1424 return *this;
1425}
1426
1427
1428template <typename Accessor>
1431{
1432 this->accessor.copy_from(i.accessor);
1433# ifdef DEBUG
1434 // do this like this, because:
1435 // if we write
1436 // "Assert (IteratorState::past_the_end || used)"
1437 // used() is called anyway, even if
1438 // state==IteratorState::past_the_end, and will then
1439 // throw the exception!
1440 if (this->state() != IteratorState::past_the_end)
1441 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1442# endif
1443 return *this;
1444}
1445
1446
1447template <typename Accessor>
1448template <typename OtherAccessor>
1451{
1452 this->accessor.copy_from(i.accessor);
1453# ifdef DEBUG
1454 // do this like this, because:
1455 // if we write
1456 // "Assert (IteratorState::past_the_end || used)"
1457 // used() is called anyway, even if
1458 // state==IteratorState::past_the_end, and will then
1459 // throw the exception!
1460 if (this->state() != IteratorState::past_the_end)
1461 Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
1462# endif
1463 return *this;
1464}
1465
1466
1467template <typename Accessor>
1470{
1472 (this->state() == IteratorState::valid))
1473 if (this->accessor.used() == true)
1474 return *this;
1475 return *this;
1476}
1477
1478
1479template <typename Accessor>
1482{
1483 TriaIterator<Accessor> tmp(*this);
1484 operator++();
1485
1486 return tmp;
1487}
1488
1489
1490template <typename Accessor>
1493{
1495 (this->state() == IteratorState::valid))
1496 if (this->accessor.used() == true)
1497 return *this;
1498 return *this;
1499}
1500
1501
1502template <typename Accessor>
1505{
1506 TriaIterator<Accessor> tmp(*this);
1507 operator--();
1508
1509 return tmp;
1510}
1511
1512
1513/*----------------------- functions: TriaActiveIterator ---------------*/
1514
1515
1516template <typename Accessor>
1518 : TriaIterator<Accessor>()
1519{}
1520
1521
1522template <typename Accessor>
1525 : TriaIterator<Accessor>(static_cast<TriaIterator<Accessor>>(i))
1526{}
1527
1528
1529template <typename Accessor>
1532 : TriaIterator<Accessor>(i)
1533{
1534# ifdef DEBUG
1535 // do this like this, because:
1536 // if we write
1537 // "Assert (IteratorState::past_the_end || !has_children())"
1538 // has_children() is called anyway, even if
1539 // state==IteratorState::past_the_end, and will then
1540 // throw the exception!
1541 if (this->state() != IteratorState::past_the_end)
1542 Assert(this->accessor.has_children() == false,
1543 ExcAssignmentOfInactiveObject());
1544# endif
1545}
1546
1547
1548template <typename Accessor>
1550 const TriaIterator<Accessor> &i)
1551 : TriaIterator<Accessor>(i)
1552{
1553# ifdef DEBUG
1554 // do this like this, because:
1555 // if we write
1556 // "Assert (IteratorState::past_the_end || !has_children())"
1557 // has_children() is called anyway, even if
1558 // state==IteratorState::past_the_end, and will then
1559 // throw the exception!
1560 if (this->state() != IteratorState::past_the_end)
1561 Assert(this->accessor.has_children() == false,
1562 ExcAssignmentOfInactiveObject());
1563# endif
1564}
1565
1566
1567template <typename Accessor>
1570 const int level,
1571 const int index,
1572 const typename Accessor::AccessorData *local_data)
1573 : TriaIterator<Accessor>(parent, level, index, local_data)
1574{
1575# ifdef DEBUG
1576 // do this like this, because:
1577 // if we write
1578 // "Assert (IteratorState::past_the_end || !has_children())"
1579 // has_children() is called anyway, even if
1580 // state==IteratorState::past_the_end, and will then
1581 // throw the exception!
1582 if (this->state() != IteratorState::past_the_end)
1583 Assert(this->accessor.has_children() == false,
1584 ExcAssignmentOfInactiveObject());
1585# endif
1586}
1587
1588
1589template <typename Accessor>
1591 const TriaAccessorBase<Accessor::structure_dimension,
1592 Accessor::dimension,
1593 Accessor::space_dimension> &tria_accessor,
1594 const typename Accessor::AccessorData *local_data)
1595 : TriaIterator<Accessor>(tria_accessor, local_data)
1596{
1597# ifdef DEBUG
1598 // do this like this, because:
1599 // if we write
1600 // "Assert (IteratorState::past_the_end || !has_children())"
1601 // has_children() is called anyway, even if
1602 // state==IteratorState::past_the_end, and will then
1603 // throw the exception!
1604 if (this->state() != IteratorState::past_the_end)
1605 Assert(this->accessor.has_children() == false,
1606 ExcAssignmentOfInactiveObject());
1607# endif
1608}
1609
1610
1611template <typename Accessor>
1614{
1615 this->accessor.copy_from(i.accessor);
1616 return *this;
1617}
1618
1619
1620template <typename Accessor>
1621template <class OtherAccessor>
1625{
1626 this->accessor.copy_from(i.accessor);
1627 return *this;
1628}
1629
1630
1631template <typename Accessor>
1634{
1635 this->accessor.copy_from(i.accessor);
1636# ifdef DEBUG
1637 // do this like this, because:
1638 // if we write
1639 // "Assert (IteratorState::past_the_end || !has_children())"
1640 // has_children() is called anyway, even if
1641 // state==IteratorState::past_the_end, and will then
1642 // throw the exception!
1643 if (this->state() != IteratorState::past_the_end)
1644 Assert(this->accessor.used() && this->accessor.has_children() == false,
1645 ExcAssignmentOfInactiveObject());
1646# endif
1647 return *this;
1648}
1649
1650
1651template <typename Accessor>
1652template <class OtherAccessor>
1655{
1656 this->accessor.copy_from(i.accessor);
1657# ifdef DEBUG
1658 // do this like this, because:
1659 // if we write
1660 // "Assert (IteratorState::past_the_end || !has_children())"
1661 // has_children() is called anyway, even if
1662 // state==IteratorState::past_the_end, and will then
1663 // throw the exception!
1664 if (this->state() != IteratorState::past_the_end)
1665 Assert(this->accessor.used() && this->accessor.has_children() == false,
1666 ExcAssignmentOfInactiveObject());
1667# endif
1668 return *this;
1669}
1670
1671
1672template <typename Accessor>
1673template <class OtherAccessor>
1676{
1677 this->accessor.copy_from(i.accessor);
1678# ifdef DEBUG
1679 // do this like this, because:
1680 // if we write
1681 // "Assert (IteratorState::past_the_end || !has_children())"
1682 // has_children() is called anyway, even if
1683 // state==IteratorState::past_the_end, and will then
1684 // throw the exception!
1685 if (this->state() != IteratorState::past_the_end)
1686 Assert(this->accessor.has_children() == false,
1687 ExcAssignmentOfInactiveObject());
1688# endif
1689 return *this;
1690}
1691
1692
1693template <typename Accessor>
1696{
1697 this->accessor.copy_from(i.accessor);
1698# ifdef DEBUG
1699 // do this like this, because:
1700 // if we write
1701 // "Assert (IteratorState::past_the_end || !has_children())"
1702 // has_children() is called anyway, even if
1703 // state==IteratorState::past_the_end, and will then
1704 // throw the exception!
1705 if (this->state() != IteratorState::past_the_end)
1706 Assert(this->accessor.has_children() == false,
1707 ExcAssignmentOfInactiveObject());
1708# endif
1709 return *this;
1710}
1711
1712
1713template <typename Accessor>
1716{
1718 (this->state() == IteratorState::valid))
1719 if (this->accessor.has_children() == false)
1720 return *this;
1721 return *this;
1722}
1723
1724
1725template <typename Accessor>
1728{
1730 operator++();
1731
1732 return tmp;
1733}
1734
1735
1736template <typename Accessor>
1739{
1741 (this->state() == IteratorState::valid))
1742 if (this->accessor.has_children() == false)
1743 return *this;
1744 return *this;
1745}
1746
1747
1748template <typename Accessor>
1751{
1753 operator--();
1754
1755 return tmp;
1756}
1757
1758#endif
1759
1761
1762#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:518
#define DEAL_II_CXX20_REQUIRES(condition)
Definition config.h:190
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:519
unsigned int level
Definition grid_out.cc:4632
static ::ExceptionBase & ExcAssignmentOfUnusedObject()
#define DeclException0(Exception0)
Definition exceptions.h:468
static ::ExceptionBase & ExcAssignmentOfInactiveObject()
#define Assert(cond, exc)
static ::ExceptionBase & ExcAdvanceInvalidObject()
static ::ExceptionBase & ExcInvalidComparison()
#define DeclException1(Exception1, type1, outsequence)
Definition exceptions.h:513
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)