Skip to content

Commit 588ff60

Browse files
luk036luk036
committed
add comments
1 parent 3fd6b65 commit 588ff60

File tree

5 files changed

+223
-9
lines changed

5 files changed

+223
-9
lines changed

‎include/py2cpp/dict.hpp‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,11 @@
1010

1111
namespace py {
1212

13+
/**
14+
* @brief
15+
*
16+
* @tparam Iter
17+
*/
1318
template <typename Iter> struct key_iterator : Iter {
1419
explicit key_iterator(Iter it) : Iter(it) {}
1520
auto operator*() const -> const auto & { return Iter::operator*().first; }

‎include/py2cpp/enumerate.hpp‎

Lines changed: 42 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -9,33 +9,72 @@ namespace py {
99

1010
namespace detail {
1111

12+
/**
13+
* @brief
14+
*
15+
* @tparam T
16+
*/
1217
template <typename T> struct EnumerateIterator {
1318
typedef decltype(std::begin(std::declval<T>())) TIter;
1419
using iter_ref = typename std::iterator_traits<TIter>::reference;
1520

1621
size_t i;
1722
TIter iter;
1823

24+
/**
25+
* @brief
26+
*
27+
* @param other
28+
* @return true
29+
* @return false
30+
*/
1931
auto operator!=(const EnumerateIterator &other) const -> bool {
2032
return iter != other.iter;
2133
}
2234

35+
/**
36+
* @brief
37+
*
38+
* @return EnumerateIterator&
39+
*/
2340
EnumerateIterator &operator++() {
2441
++i;
2542
++iter;
2643
return *this;
2744
}
2845

46+
/**
47+
* @brief
48+
*
49+
* @return std::pair<size_t, iter_ref>
50+
*/
2951
auto operator*() -> std::pair<size_t, iter_ref> {
3052
return std::pair<size_t, iter_ref>{i, *iter};
3153
}
3254
};
3355

56+
/**
57+
* @brief
58+
*
59+
* @tparam T
60+
*/
3461
template <typename T> struct EnumerateIterableWrapper {
3562
T &iterable;
63+
64+
/**
65+
* @brief
66+
*
67+
* @return EnumerateIterator<T>
68+
*/
3669
auto begin() const -> EnumerateIterator<T> {
3770
return EnumerateIterator<T>{0, std::begin(iterable)};
3871
}
72+
73+
/**
74+
* @brief
75+
*
76+
* @return EnumerateIterator<T>
77+
*/
3978
auto end() const -> EnumerateIterator<T> {
4079
return EnumerateIterator<T>{0, std::end(iterable)};
4180
}
@@ -47,10 +86,8 @@ template <typename T> struct EnumerateIterableWrapper {
4786
* @brief
4887
*
4988
* @tparam T
50-
* @tparam decltype(std::begin(std::declval<T>()))
51-
* @tparam decltype(std::end(std::declval<T>()))
5289
* @param[in] iterable
53-
* @return constexpr auto
90+
* @return detail::EnumerateIterableWrapper<T>
5491
*/
5592
template <typename T>
5693
inline auto enumerate(T &iterable) -> detail::EnumerateIterableWrapper<T> {
@@ -61,10 +98,8 @@ inline auto enumerate(T &iterable) -> detail::EnumerateIterableWrapper<T> {
6198
* @brief
6299
*
63100
* @tparam T
64-
* @tparam decltype(std::begin(std::declval<T>()))
65-
* @tparam decltype(std::end(std::declval<T>()))
66-
* @param[in] iterable
67-
* @return constexpr auto
101+
* @param iterable
102+
* @return detail::EnumerateIterableWrapper<const T>
68103
*/
69104
template <typename T>
70105
inline auto const_enumerate(const T &iterable)

‎include/py2cpp/lict.hpp‎

Lines changed: 61 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,11 @@
66

77
namespace py {
88

9+
/**
10+
* @brief Dict-like data structure by std::vector and Range
11+
*
12+
* @tparam T
13+
*/
914
template <typename T> class Lict {
1015
public:
1116
using key_type = size_t;
@@ -18,27 +23,81 @@ template <typename T> class Lict {
1823
std::vector<T> _lst;
1924

2025
public:
21-
Lict(std::vector<T> lst)
26+
/**
27+
* @brief Construct a new Lict object
28+
*
29+
* @param lst
30+
*/
31+
explicit Lict(std::vector<T> lst)
2232
: _rng{py::range(lst.size())}, _lst(std::move(lst)) {}
2333

34+
/**
35+
* @brief
36+
*
37+
* @param key
38+
* @return T&
39+
*/
2440
T &operator[](const key_type &key) { return this->_lst[key]; }
2541

42+
/**
43+
* @brief
44+
*
45+
* @param key
46+
* @return const T&
47+
*/
2648
const T &operator[](const key_type &key) const { return this->_lst[key]; }
2749

28-
// void __delitem__() { throw std::runtime_error("NotImplementedError"); }
50+
// void erase() { throw std::runtime_error("NotImplementedError"); }
2951

52+
/**
53+
* @brief
54+
*
55+
* @return iterator
56+
*/
3057
iterator begin() const { return this->_rng.begin(); }
3158

59+
/**
60+
* @brief
61+
*
62+
* @return iterator
63+
*/
3264
iterator end() const { return this->_rng.end(); }
3365

66+
/**
67+
* @brief
68+
*
69+
* @param key
70+
* @return true
71+
* @return false
72+
*/
3473
bool contains(const key_type &key) const { return this->_rng.contains(key); }
3574

75+
/**
76+
* @brief
77+
*
78+
* @return size_t
79+
*/
3680
size_t size() const { return this->_rng.size(); }
3781

82+
/**
83+
* @brief
84+
*
85+
* @return auto&
86+
*/
3887
auto &values() { return this->_lst; }
3988

89+
/**
90+
* @brief
91+
*
92+
* @return const auto&
93+
*/
4094
const auto &values() const { return this->_lst; }
4195

96+
/**
97+
* @brief
98+
*
99+
* @return auto
100+
*/
42101
auto items() { return py::enumerate(this->_lst); }
43102
};
44103

‎include/py2cpp/nx2bgl.hpp‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -200,10 +200,20 @@ template <typename _Graph> class GrAdaptor : public VertexView<_Graph> {
200200
// GrAdaptor& operator=(const GrAdaptor&) = delete; // don't assign
201201
// GrAdaptor(GrAdaptor&&) noexcept = default; // don't copy
202202

203+
/**
204+
* @brief
205+
*
206+
* @return auto
207+
*/
203208
[[nodiscard]] auto number_of_nodes() const {
204209
return boost::num_vertices(*this);
205210
}
206211

212+
/**
213+
* @brief
214+
*
215+
* @return auto
216+
*/
207217
[[nodiscard]] auto number_of_edges() const { return boost::num_edges(*this); }
208218

209219
/**

‎include/py2cpp/range.hpp‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,11 @@
1212

1313
namespace py {
1414

15+
/**
16+
* @brief
17+
*
18+
* @tparam T
19+
*/
1520
template <typename T> struct RangeIterator {
1621
using iterator_category = std::output_iterator_tag;
1722
using difference_type = std::ptrdiff_t;
@@ -22,25 +27,70 @@ template <typename T> struct RangeIterator {
2227
using key_type = T; // luk:
2328

2429
T i;
30+
31+
/**
32+
* @brief
33+
*
34+
* @param other
35+
* @return true
36+
* @return false
37+
*/
2538
constexpr auto operator!=(const RangeIterator &other) const -> bool {
2639
return this->i != other.i;
2740
}
41+
42+
/**
43+
* @brief
44+
*
45+
* @param other
46+
* @return true
47+
* @return false
48+
*/
2849
constexpr auto operator==(const RangeIterator &other) const -> bool {
2950
return this->i == other.i;
3051
}
52+
53+
/**
54+
* @brief
55+
*
56+
* @return const_reference
57+
*/
3158
CONSTEXPR14 auto operator*() const -> const_reference { return this->i; }
59+
60+
/**
61+
* @brief
62+
*
63+
* @return reference
64+
*/
3265
CONSTEXPR14 auto operator*() -> reference { return this->i; }
66+
67+
/**
68+
* @brief
69+
*
70+
* @return RangeIterator&
71+
*/
3372
CONSTEXPR14 auto operator++() -> RangeIterator & {
3473
++this->i;
3574
return *this;
3675
}
76+
77+
/**
78+
* @brief
79+
*
80+
* @return RangeIterator
81+
*/
3782
CONSTEXPR14 auto operator++(int) -> RangeIterator {
3883
auto temp = *this;
3984
++(*this);
4085
return temp;
4186
}
4287
};
4388

89+
/**
90+
* @brief
91+
*
92+
* @tparam T
93+
*/
4494
template <typename T> struct Range {
4595
public:
4696
using iterator = RangeIterator<T>;
@@ -52,27 +102,82 @@ template <typename T> struct Range {
52102

53103
T start;
54104
T stop;
105+
106+
/**
107+
* @brief
108+
*
109+
* @return iterator
110+
*/
55111
constexpr auto begin() const -> iterator { return iterator{this->start}; }
112+
113+
/**
114+
* @brief
115+
*
116+
* @return iterator
117+
*/
56118
constexpr auto end() const -> iterator { return iterator{this->stop}; }
119+
120+
/**
121+
* @brief
122+
*
123+
* @return true
124+
* @return false
125+
*/
57126
constexpr auto empty() const -> bool { return this->stop == this->start; }
127+
128+
/**
129+
* @brief
130+
*
131+
* @return size_t
132+
*/
58133
constexpr auto size() const -> size_t {
59134
return static_cast<size_t>(this->stop - this->start);
60135
}
136+
137+
/**
138+
* @brief
139+
*
140+
* @param n
141+
* @return T
142+
*/
61143
constexpr auto operator[](size_t n) const -> T {
62144
return T(this->start + n);
63145
} // no bounds checking
146+
147+
/**
148+
* @brief
149+
*
150+
* @param n
151+
* @return true
152+
* @return false
153+
*/
64154
constexpr auto contains(T n) const -> bool {
65155
return !(n < this->start) && n < this->stop;
66156
}
67157
};
68158

159+
/**
160+
* @brief
161+
*
162+
* @tparam T
163+
* @param start
164+
* @param stop
165+
* @return Range<T>
166+
*/
69167
template <typename T> CONSTEXPR14 auto range(T start, T stop) -> Range<T> {
70168
if (stop < start) {
71169
stop = start;
72170
}
73171
return Range<T>{start, stop};
74172
}
75173

174+
/**
175+
* @brief
176+
*
177+
* @tparam T
178+
* @param stop
179+
* @return Range<T>
180+
*/
76181
template <typename T> CONSTEXPR14 auto range(T stop) -> Range<T> {
77182
return range(T(0), stop);
78183
}

0 commit comments

Comments
 (0)