// sol2 // The MIT License (MIT) // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors // Permission is hereby granted, free of charge, to any person obtaining a copy of // this software and associated documentation files (the "Software"), to deal in // the Software without restriction, including without limitation the rights to // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of // the Software, and to permit persons to whom the Software is furnished to do so, // subject to the following conditions: // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS // FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #ifndef SOL_STACK_ITERATOR_HPP #define SOL_STACK_ITERATOR_HPP #include #include #include namespace sol { template struct stack_iterator { typedef meta::conditional_t reference; typedef meta::conditional_t pointer; typedef proxy_t value_type; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; lua_State* L; int index; int stacktop; proxy_t sp; stack_iterator() : L(nullptr), index((std::numeric_limits::max)()), stacktop((std::numeric_limits::max)()), sp() { } stack_iterator(const stack_iterator& r) : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) { } stack_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) { } reference operator*() { return proxy_t(L, index); } reference operator*() const { return proxy_t(L, index); } pointer operator->() { sp = proxy_t(L, index); return &sp; } pointer operator->() const { const_cast(sp) = proxy_t(L, index); return &sp; } stack_iterator& operator++() { ++index; return *this; } stack_iterator operator++(int) { auto r = *this; this->operator++(); return r; } stack_iterator& operator--() { --index; return *this; } stack_iterator operator--(int) { auto r = *this; this->operator--(); return r; } stack_iterator& operator+=(difference_type idx) { index += static_cast(idx); return *this; } stack_iterator& operator-=(difference_type idx) { index -= static_cast(idx); return *this; } difference_type operator-(const stack_iterator& r) const { return index - r.index; } stack_iterator operator+(difference_type idx) const { stack_iterator r = *this; r += idx; return r; } reference operator[](difference_type idx) const { return proxy_t(L, index + static_cast(idx)); } bool operator==(const stack_iterator& r) const { if (stacktop == (std::numeric_limits::max)()) { return r.index == r.stacktop; } else if (r.stacktop == (std::numeric_limits::max)()) { return index == stacktop; } return index == r.index; } bool operator!=(const stack_iterator& r) const { return !(this->operator==(r)); } bool operator<(const stack_iterator& r) const { return index < r.index; } bool operator>(const stack_iterator& r) const { return index > r.index; } bool operator<=(const stack_iterator& r) const { return index <= r.index; } bool operator>=(const stack_iterator& r) const { return index >= r.index; } }; template inline stack_iterator operator+( typename stack_iterator::difference_type n, const stack_iterator& r) { return r + n; } } // namespace sol #endif // SOL_STACK_ITERATOR_HPP