Skip to content

Commit 973f8e0

Browse files
malibertymaliberty
committed
odb: const methods on dbIterator and derived
Signed-off-by: Matt Liberty <[email protected]>
1 parent 1f0b987 commit 973f8e0

File tree

88 files changed

+662
-670
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

88 files changed

+662
-670
lines changed

‎src/odb/include/odb/dbIterator.h‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -15,14 +15,14 @@ class dbObjectTable;
1515
class dbIterator
1616
{
1717
public:
18-
virtual bool reversible() = 0;
19-
virtual bool orderReversed() = 0;
18+
virtual bool reversible() const = 0;
19+
virtual bool orderReversed() const = 0;
2020
virtual void reverse(dbObject* parent) = 0;
21-
virtual uint sequential() = 0;
22-
virtual uint size(dbObject* parent) = 0;
23-
virtual uint begin(dbObject* parent) = 0;
24-
virtual uint end(dbObject* parent) = 0;
25-
virtual uint next(uint id, ...) = 0;
21+
virtual uint sequential() const = 0;
22+
virtual uint size(dbObject* parent) const = 0;
23+
virtual uint begin(dbObject* parent) const = 0;
24+
virtual uint end(dbObject* parent) const = 0;
25+
virtual uint next(uint id, ...) const = 0;
2626
virtual dbObject* getObject(uint id, ...) = 0;
2727
virtual ~dbIterator() = default;
2828
};

‎src/odb/include/odb/dbSet.h‎

Lines changed: 39 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -20,13 +20,6 @@ class dbSet;
2020
template <class T>
2121
class dbSetIterator
2222
{
23-
friend class dbSet<T>;
24-
25-
dbIterator* _itr;
26-
uint _cur;
27-
28-
dbSetIterator(dbIterator* itr, uint id);
29-
3023
public:
3124
using value_type = T*;
3225
using difference_type = std::ptrdiff_t;
@@ -37,13 +30,21 @@ class dbSetIterator
3730
dbSetIterator();
3831
dbSetIterator(const dbSetIterator& it) = default;
3932

40-
bool operator==(const dbSetIterator<T>& it);
41-
bool operator!=(const dbSetIterator<T>& it);
33+
bool operator==(const dbSetIterator<T>& it) const;
34+
bool operator!=(const dbSetIterator<T>& it) const;
4235

4336
T* operator*();
4437
T* operator->();
4538
dbSetIterator<T>& operator++();
4639
dbSetIterator<T> operator++(int);
40+
41+
private:
42+
dbSetIterator(dbIterator* itr, uint id);
43+
44+
dbIterator* itr_;
45+
uint cur_;
46+
47+
friend class dbSet<T>;
4748
};
4849

4950
///
@@ -71,44 +72,41 @@ class dbSetIterator
7172
template <class T>
7273
class dbSet
7374
{
74-
dbIterator* _itr;
75-
dbObject* _parent;
76-
7775
public:
7876
using iterator = dbSetIterator<T>;
7977

8078
dbSet()
8179
{
82-
_itr = nullptr;
83-
_parent = nullptr;
80+
itr_ = nullptr;
81+
parent_ = nullptr;
8482
}
8583

8684
dbSet(dbObject* parent, dbIterator* itr)
8785
{
88-
_parent = parent;
89-
_itr = itr;
86+
parent_ = parent;
87+
itr_ = itr;
9088
}
9189

9290
dbSet(const dbSet<T>& c)
9391
{
94-
_itr = c._itr;
95-
_parent = c._parent;
92+
itr_ = c.itr_;
93+
parent_ = c.parent_;
9694
}
9795

9896
///
9997
/// Returns the number of items in this set.
10098
///
101-
uint size() { return _itr->size(_parent); }
99+
uint size() { return itr_->size(parent_); }
102100

103101
///
104102
/// Return a begin() iterator.
105103
///
106-
iterator begin() { return iterator(_itr, _itr->begin(_parent)); }
104+
iterator begin() { return iterator(itr_, itr_->begin(parent_)); }
107105

108106
///
109107
/// Return an end() iterator.
110108
///
111-
iterator end() { return iterator(_itr, _itr->end(_parent)); }
109+
iterator end() { return iterator(itr_, itr_->end(parent_)); }
112110

113111
///
114112
/// If this set is sequential, this function will return the database
@@ -119,80 +117,84 @@ class dbSet
119117
///
120118
/// If this set is non-sequential then it returns 0.
121119
///
122-
uint sequential() { return _itr->sequential(); }
120+
uint sequential() { return itr_->sequential(); }
123121

124122
///
125123
/// Returns true if this set is reversible.
126124
///
127-
bool reversible() { return _itr->reversible(); }
125+
bool reversible() { return itr_->reversible(); }
128126

129127
///
130128
/// Returns true if the is iterated in the reverse order that
131129
/// it was created.
132130
///
133-
bool orderReversed() { return _itr->orderReversed(); }
131+
bool orderReversed() { return itr_->orderReversed(); }
134132

135133
///
136134
/// Reverse the order of this set.
137135
///
138-
void reverse() { _itr->reverse(_parent); }
136+
void reverse() { itr_->reverse(parent_); }
139137

140138
///
141139
/// Returns true if set is empty
142140
///
143141
bool empty() { return begin() == end(); }
142+
143+
private:
144+
dbIterator* itr_;
145+
dbObject* parent_;
144146
};
145147

146148
template <class T>
147149
inline dbSetIterator<T>::dbSetIterator()
148150
{
149-
_itr = nullptr;
150-
_cur = 0;
151+
itr_ = nullptr;
152+
cur_ = 0;
151153
}
152154

153155
template <class T>
154156
inline dbSetIterator<T>::dbSetIterator(dbIterator* itr, uint id)
155157
{
156-
_itr = itr;
157-
_cur = id;
158+
itr_ = itr;
159+
cur_ = id;
158160
}
159161

160162
template <class T>
161-
inline bool dbSetIterator<T>::operator==(const dbSetIterator& it)
163+
inline bool dbSetIterator<T>::operator==(const dbSetIterator& it) const
162164
{
163-
return (_itr == it._itr) && (_cur == it._cur);
165+
return (itr_ == it.itr_) && (cur_ == it.cur_);
164166
}
165167

166168
template <class T>
167-
inline bool dbSetIterator<T>::operator!=(const dbSetIterator& it)
169+
inline bool dbSetIterator<T>::operator!=(const dbSetIterator& it) const
168170
{
169-
return (_itr != it._itr) || (_cur != it._cur);
171+
return !(*this == it);
170172
}
171173

172174
template <class T>
173175
inline T* dbSetIterator<T>::operator*()
174176
{
175-
return (T*) _itr->getObject(_cur);
177+
return (T*) itr_->getObject(cur_);
176178
}
177179

178180
template <class T>
179181
inline T* dbSetIterator<T>::operator->()
180182
{
181-
return (T*) _itr->getObject(_cur);
183+
return (T*) itr_->getObject(cur_);
182184
}
183185

184186
template <class T>
185187
inline dbSetIterator<T>& dbSetIterator<T>::operator++()
186188
{
187-
_cur = _itr->next(_cur);
189+
cur_ = itr_->next(cur_);
188190
return *this;
189191
}
190192

191193
template <class T>
192194
inline dbSetIterator<T> dbSetIterator<T>::operator++(int)
193195
{
194196
dbSetIterator it(*this);
195-
_cur = _itr->next(_cur);
197+
cur_ = itr_->next(cur_);
196198
return it;
197199
}
198200

‎src/odb/src/codeGenerator/templates/itr.cpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -21,12 +21,12 @@ namespace odb {
2121
////////////////////////////////////////////////////////////////////
2222

2323

24-
bool {{itr.name}}::reversible()
24+
bool {{itr.name}}::reversible() const
2525
{
2626
return {{itr.reversible}};
2727
}
2828

29-
bool {{itr.name}}::orderReversed()
29+
bool {{itr.name}}::orderReversed() const
3030
{
3131
return {{itr.orderReversed}};
3232
}
@@ -37,12 +37,12 @@ void {{itr.name}}::reverse(dbObject* parent)
3737
//User Code End reverse
3838
}
3939

40-
uint {{itr.name}}::sequential()
40+
uint {{itr.name}}::sequential() const
4141
{
4242
return {{itr.sequential}};
4343
}
4444

45-
uint {{itr.name}}::size(dbObject* parent)
45+
uint {{itr.name}}::size(dbObject* parent) const
4646
{
4747
uint id;
4848
uint cnt = 0;
@@ -55,18 +55,18 @@ uint {{itr.name}}::size(dbObject* parent)
5555
return cnt;
5656
}
5757

58-
uint {{itr.name}}::begin(dbObject* parent)
58+
uint {{itr.name}}::begin(dbObject* parent) const
5959
{
6060
//User Code Begin begin
6161
//User Code End begin
6262
}
6363

64-
uint {{itr.name}}::end(dbObject* /* unused: parent */)
64+
uint {{itr.name}}::end(dbObject* /* unused: parent */) const
6565
{
6666
return 0;
6767
}
6868

69-
uint {{itr.name}}::next(uint id, ...)
69+
uint {{itr.name}}::next(uint id, ...) const
7070
{
7171
//User Code Begin next
7272
//User Code End next

‎src/odb/src/codeGenerator/templates/itr.h‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,14 @@ namespace odb {
2222
public:
2323
{{itr.name}}({{macros.table_type(itr)}}* {{itr.tableName}}) { _{{itr.tableName}} = {{itr.tableName}}; }
2424

25-
bool reversible() override;
26-
bool orderReversed() override;
25+
bool reversible() const override;
26+
bool orderReversed() const override;
2727
void reverse(dbObject* parent) override;
28-
uint sequential() override;
29-
uint size(dbObject* parent) override;
30-
uint begin(dbObject* parent) override;
31-
uint end(dbObject* parent) override;
32-
uint next(uint id, ...) override;
28+
uint sequential() const override;
29+
uint size(dbObject* parent) const override;
30+
uint begin(dbObject* parent) const override;
31+
uint end(dbObject* parent) const override;
32+
uint next(uint id, ...) const override;
3333
dbObject* getObject(uint id, ...) override;
3434
// User Code Begin Methods
3535
// User Code End Methods

‎src/odb/src/db/dbBPinItr.cpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -21,12 +21,12 @@ namespace odb {
2121
//
2222
// BPins are ordered by io-type and cannot be reversed.
2323
//
24-
bool dbBPinItr::reversible()
24+
bool dbBPinItr::reversible() const
2525
{
2626
return true;
2727
}
2828

29-
bool dbBPinItr::orderReversed()
29+
bool dbBPinItr::orderReversed() const
3030
{
3131
return true;
3232
}
@@ -48,12 +48,12 @@ void dbBPinItr::reverse(dbObject* parent)
4848
bterm->_bpins = list;
4949
}
5050

51-
uint dbBPinItr::sequential()
51+
uint dbBPinItr::sequential() const
5252
{
5353
return 0;
5454
}
5555

56-
uint dbBPinItr::size(dbObject* parent)
56+
uint dbBPinItr::size(dbObject* parent) const
5757
{
5858
uint id;
5959
uint cnt = 0;
@@ -66,18 +66,18 @@ uint dbBPinItr::size(dbObject* parent)
6666
return cnt;
6767
}
6868

69-
uint dbBPinItr::begin(dbObject* parent)
69+
uint dbBPinItr::begin(dbObject* parent) const
7070
{
7171
_dbBTerm* bterm = (_dbBTerm*) parent;
7272
return bterm->_bpins;
7373
}
7474

75-
uint dbBPinItr::end(dbObject* /* unused: parent */)
75+
uint dbBPinItr::end(dbObject* /* unused: parent */) const
7676
{
7777
return 0;
7878
}
7979

80-
uint dbBPinItr::next(uint id, ...)
80+
uint dbBPinItr::next(uint id, ...) const
8181
{
8282
_dbBPin* bpin = _bpin_tbl->getPtr(id);
8383
return bpin->next_bpin_;

‎src/odb/src/db/dbBPinItr.h‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -18,14 +18,14 @@ class dbBPinItr : public dbIterator
1818
public:
1919
dbBPinItr(dbTable<_dbBPin>* bpin_tbl) { _bpin_tbl = bpin_tbl; }
2020

21-
bool reversible() override;
22-
bool orderReversed() override;
21+
bool reversible() const override;
22+
bool orderReversed() const override;
2323
void reverse(dbObject* parent) override;
24-
uint sequential() override;
25-
uint size(dbObject* parent) override;
26-
uint begin(dbObject* parent) override;
27-
uint end(dbObject* parent) override;
28-
uint next(uint id, ...) override;
24+
uint sequential() const override;
25+
uint size(dbObject* parent) const override;
26+
uint begin(dbObject* parent) const override;
27+
uint end(dbObject* parent) const override;
28+
uint next(uint id, ...) const override;
2929
dbObject* getObject(uint id, ...) override;
3030
};
3131

0 commit comments

Comments
 (0)