From 89122d2415eece242ff891691e4a549966e67f31 Mon Sep 17 00:00:00 2001 From: Raoul Gough Date: Wed, 15 Oct 2003 11:22:40 +0000 Subject: [PATCH] Rename CamelCase variable and function names [SVN r20386] --- .../python/suite/indexing/container_proxy.hpp | 138 +++++++++--------- .../python/suite/indexing/element_proxy.hpp | 38 ++--- .../suite/indexing/int_slice_helper.hpp | 38 ++--- .../python/suite/indexing/iterator_pair.hpp | 16 +- .../python/suite/indexing/python_iterator.hpp | 10 +- .../suite/indexing/shared_proxy_impl.hpp | 36 ++--- include/boost/python/suite/indexing/slice.hpp | 20 +-- .../python/suite/indexing/slice_handler.hpp | 8 +- .../boost/python/suite/indexing/visitor.hpp | 26 ++-- src/indexing/python_iterator.cpp | 24 +-- src/indexing/slice.cpp | 24 +-- 11 files changed, 189 insertions(+), 189 deletions(-) diff --git a/include/boost/python/suite/indexing/container_proxy.hpp b/include/boost/python/suite/indexing/container_proxy.hpp index f1c75fe1..15c531a6 100755 --- a/include/boost/python/suite/indexing/container_proxy.hpp +++ b/include/boost/python/suite/indexing/container_proxy.hpp @@ -148,37 +148,37 @@ namespace boost { namespace python { namespace indexing { private: typedef boost::shared_ptr pointer_impl; - typedef std::map MapType; - typedef typename MapType::iterator MapIterator; - typedef typename MapType::value_type MapEntry; + typedef std::map map_type; + typedef typename map_type::iterator map_iterator; + typedef typename map_type::value_type map_value; private: Container &raw_container(); - static void detach_if_shared (MapEntry const &); + static void detach_if_shared (map_value const &); - void adjustIndexes (MapIterator, MapIterator, difference_type offset); - void adjustIndexesReverse (MapIterator, MapIterator, difference_type offs); - void adjustIndex (MapIterator, difference_type offset); + void adjust_indexes_front (map_iterator, map_iterator, difference_type); + void adjust_indexes_back (map_iterator, map_iterator, difference_type); + void adjust_index (map_iterator, difference_type offset); private: - held_type myHeldObj; - MapType myMap; + held_type m_held_obj; + map_type m_map; }; template container_proxy ::container_proxy () - : myHeldObj () - , myMap () + : m_held_obj () + , m_map () { } template container_proxy - ::container_proxy (held_type const &heldType) - : myHeldObj (heldType) - , myMap () + ::container_proxy (held_type const &held) + : m_held_obj (held) + , m_map () { } @@ -186,8 +186,8 @@ namespace boost { namespace python { namespace indexing { template container_proxy ::container_proxy (Iter start, Iter finish) - : myHeldObj (Holder::create()) - , myMap () + : m_held_obj (Holder::create()) + , m_map () { insert (begin(), start, finish); } @@ -195,8 +195,8 @@ namespace boost { namespace python { namespace indexing { template container_proxy ::container_proxy (container_proxy const ©) - : myHeldObj (Holder::copy (copy.myHeldObj)) - , myMap () // Do *not* duplicate map + : m_held_obj (Holder::copy (copy.m_held_obj)) + , m_map () // Do *not* duplicate map { } @@ -206,9 +206,9 @@ namespace boost { namespace python { namespace indexing { ::operator= (container_proxy const ©) { // All of our contained values are about to be dis-owned - std::for_each (myMap.begin(), myMap.end(), detach_if_shared); - myMap.clear(); - Holder::assign (myHeldObj, copy.myHeldObj); + std::for_each (m_map.begin(), m_map.end(), detach_if_shared); + m_map.clear(); + Holder::assign (m_held_obj, copy.m_held_obj); return *this; } @@ -217,8 +217,8 @@ namespace boost { namespace python { namespace indexing { ::~container_proxy () { // All of our contained values are about to be dis-owned - std::for_each (myMap.begin(), myMap.end(), detach_if_shared); - Holder::pre_destruction (myHeldObj); + std::for_each (m_map.begin(), m_map.end(), detach_if_shared); + Holder::pre_destruction (m_held_obj); } template @@ -226,7 +226,7 @@ namespace boost { namespace python { namespace indexing { container_proxy ::raw_container () { - return Holder::get (myHeldObj); + return Holder::get (m_held_obj); } template @@ -234,7 +234,7 @@ namespace boost { namespace python { namespace indexing { container_proxy ::raw_container () const { - return Holder::get (myHeldObj); + return Holder::get (m_held_obj); } template @@ -242,7 +242,7 @@ namespace boost { namespace python { namespace indexing { container_proxy ::at (size_type index) { - pointer_impl &entry = myMap[index]; + pointer_impl &entry = m_map[index]; if (!entry.get()) { @@ -292,36 +292,36 @@ namespace boost { namespace python { namespace indexing { container_proxy ::swap_elements (size_type index1, size_type index2) { - MapIterator iter1 = myMap.find (index1); - MapIterator iter2 = myMap.find (index2); + map_iterator iter1 = m_map.find (index1); + map_iterator iter2 = m_map.find (index2); difference_type distance = static_cast(index2) - static_cast(index1); - if ((iter1 == myMap.end()) && (iter2 == myMap.end())) + if ((iter1 == m_map.end()) && (iter2 == m_map.end())) { // No proxies exist for these indexes. } - else if ((iter1 != myMap.end()) && (iter2 == myMap.end())) + else if ((iter1 != m_map.end()) && (iter2 == m_map.end())) { // Proxy for the first index only - MapIterator temp (iter1); - adjustIndexes (iter1, ++temp, distance); // Exactly one element + map_iterator temp (iter1); + adjust_indexes_front (iter1, ++temp, distance); // Exactly one element } - else if ((iter1 == myMap.end()) && (iter2 != myMap.end())) + else if ((iter1 == m_map.end()) && (iter2 != m_map.end())) { // Proxy for the second index only - MapIterator temp (iter2); - adjustIndexes (iter2, ++temp, -distance); + map_iterator temp (iter2); + adjust_indexes_front (iter2, ++temp, -distance); } else { // Proxies for both indexes - std::swap (iter1->second->myIndex, iter2->second->myIndex); + std::swap (iter1->second->m_index, iter2->second->m_index); std::swap (iter1->second, iter2->second); } @@ -345,15 +345,15 @@ namespace boost { namespace python { namespace indexing { assert (to.ptr == this); difference_type deleting = to.index - from.index; - MapIterator erase_begin = myMap.lower_bound (from.index); - MapIterator erase_end = myMap.lower_bound (to.index); + map_iterator erase_begin = m_map.lower_bound (from.index); + map_iterator erase_end = m_map.lower_bound (to.index); // Detach any proxies for the soon-to-be-erased elements std::for_each (erase_begin, erase_end, detach_if_shared); - myMap.erase (erase_begin, erase_end); // Note: erase_end remains valid + m_map.erase (erase_begin, erase_end); // Note: erase_end remains valid // Adjust the indexes of any following proxies - adjustIndexes (erase_end, myMap.end(), -deleting); + adjust_indexes_front (erase_end, m_map.end(), -deleting); // Erase the elements from the real container raw_iterator result @@ -372,9 +372,9 @@ namespace boost { namespace python { namespace indexing { // Adjust indexes from iter.index onwards, since insert goes // before this element - adjustIndexesReverse (myMap.lower_bound (iter.index) - , myMap.end() - , 1); + adjust_indexes_back (m_map.lower_bound (iter.index) + , m_map.end() + , 1); // Insert the element into the real container raw_iterator result @@ -406,9 +406,9 @@ namespace boost { namespace python { namespace indexing { // Adjust indexes from iter.index onwanrds (insert goes before // this element) - adjustIndexesReverse (myMap.lower_bound (iter.index) - , myMap.end() - , std::distance (from, to)); + adjust_indexes_back (m_map.lower_bound (iter.index) + , m_map.end() + , std::distance (from, to)); // Insert the element into the real container raw_container().insert (raw_container().begin() + iter.index, from, to); @@ -431,7 +431,7 @@ namespace boost { namespace python { namespace indexing { template void container_proxy - ::detach_if_shared (MapEntry const &ent) + ::detach_if_shared (map_value const &ent) { if (!ent.second.unique()) { @@ -446,24 +446,24 @@ namespace boost { namespace python { namespace indexing { container_proxy ::detach_proxy (size_type index) { - MapIterator iter = myMap.find (index); + map_iterator iter = m_map.find (index); - if (iter != myMap.end()) + if (iter != m_map.end()) { detach_if_shared (*iter); - myMap.erase (iter); + m_map.erase (iter); } } template void container_proxy - ::detach_proxies (size_type fromIndex, size_type toIndex) + ::detach_proxies (size_type from_index, size_type to_index) { - MapIterator from = myMap.lower_bound (fromIndex); - MapIterator to = myMap.lower_bound (toIndex); + map_iterator from = m_map.lower_bound (from_index); + map_iterator to = m_map.lower_bound (to_index); std::for_each (from, to, detach_if_shared); - myMap.erase (from, to); + m_map.erase (from, to); } template @@ -479,27 +479,27 @@ namespace boost { namespace python { namespace indexing { template void container_proxy - ::adjustIndex (MapIterator iter, difference_type offset) + ::adjust_index (map_iterator iter, difference_type offset) { pointer_impl ptr (iter->second); // Copy the shared pointer - myMap.erase (iter); // Remove the map copy of it + m_map.erase (iter); // Remove the map copy of it if (!ptr.unique()) { // Reinsert only if there are other pointers "out there" // referring to the shared proxy - ptr->myIndex += offset; - myMap.insert (typename MapType::value_type (ptr->myIndex, ptr)); + ptr->m_index += offset; + m_map.insert (typename map_type::value_type (ptr->m_index, ptr)); } } template void container_proxy - ::adjustIndexes (MapIterator low_bound - , MapIterator high_bound - , difference_type offset) + ::adjust_indexes_front (map_iterator low_bound + , map_iterator high_bound + , difference_type offset) { // Adjust indexes in the given range of proxies by the given offset. // The adjustment is done by erasing and re-inserting the entries @@ -513,20 +513,20 @@ namespace boost { namespace python { namespace indexing { while (low_bound != high_bound) { - MapIterator target (low_bound); + map_iterator target (low_bound); ++low_bound; // Find next node before erasing the current target - adjustIndex (target, offset); + adjust_index (target, offset); } } template void container_proxy - ::adjustIndexesReverse (MapIterator low_bound - , MapIterator high_bound - , difference_type offset) + ::adjust_indexes_back (map_iterator low_bound + , map_iterator high_bound + , difference_type offset) { if (low_bound != high_bound) { @@ -536,17 +536,17 @@ namespace boost { namespace python { namespace indexing { { if (high_bound == low_bound) { - adjustIndex (high_bound, offset); // Last one to adjust + adjust_index (high_bound, offset); // Last one to adjust break; } else { - MapIterator target (high_bound); + map_iterator target (high_bound); --high_bound; // Find previous node before doing erase - adjustIndex (target, offset); // Do erase + adjust_index (target, offset); // Do erase } } } diff --git a/include/boost/python/suite/indexing/element_proxy.hpp b/include/boost/python/suite/indexing/element_proxy.hpp index 4a687c34..acf70a83 100755 --- a/include/boost/python/suite/indexing/element_proxy.hpp +++ b/include/boost/python/suite/indexing/element_proxy.hpp @@ -41,7 +41,7 @@ namespace boost { namespace python { namespace indexing { typedef typename container_proxy::raw_value_type raw_value_type; typedef typename container_proxy::size_type size_type; - proxy_pointer mPtr; + proxy_pointer m_ptr; public: typedef typename proxy_type::value_type value_type; @@ -52,18 +52,18 @@ namespace boost { namespace python { namespace indexing { typedef value_type element_type; // Alias for register_ptr_to_python - element_proxy () : mPtr () { } - explicit element_proxy (proxy_type *ptr) : mPtr (ptr) { } - element_proxy (proxy_pointer const &ptr) : mPtr (ptr) { } + element_proxy () : m_ptr () { } + explicit element_proxy (proxy_type *ptr) : m_ptr (ptr) { } + element_proxy (proxy_pointer const &ptr) : m_ptr (ptr) { } explicit element_proxy (raw_value_type const &val) - : mPtr (new proxy_type(val)) + : m_ptr (new proxy_type(val)) { // Create new standalone value (i.e. detached) } - reference operator* () const { return mPtr->operator*(); } - pointer operator-> () const { return (*mPtr).operator->(); } + reference operator* () const { return m_ptr->operator*(); } + pointer operator-> () const { return (*m_ptr).operator->(); } pointer get () const { return operator->(); } // Alias for pointer_holder // Implicit conversion to raw_value_type @@ -81,7 +81,7 @@ namespace boost { namespace python { namespace indexing { element_proxy &operator= (value_type const ©) { - proxy_type &proxy (*mPtr); + proxy_type &proxy (*m_ptr); container_proxy *container = proxy.owner(); size_type index = proxy.index(); @@ -91,7 +91,7 @@ namespace boost { namespace python { namespace indexing { // Proxy was attached before, but is now detached. Make sure // we now refer to the new element, instead of the detached // copy of the old element - mPtr = container->at (index).mPtr; + m_ptr = container->at (index).m_ptr; // Note: in the special case that this we and the container // proxy itself have the only references to the @@ -116,7 +116,7 @@ namespace boost { namespace python { namespace indexing { return (*this) = *copy; } - size_t use_count() const { return mPtr.use_count(); } // For debugging + size_t use_count() const { return m_ptr.use_count(); } // For debugging }; template @@ -127,7 +127,7 @@ namespace boost { namespace python { namespace indexing { typedef boost::shared_ptr proxy_pointer; typedef typename container_proxy::raw_value_type raw_value_type; - proxy_pointer mPtr; + proxy_pointer m_ptr; public: typedef typename proxy_type::value_type const value_type; @@ -136,28 +136,28 @@ namespace boost { namespace python { namespace indexing { typedef typename proxy_type::iterator_category iterator_category; typedef typename proxy_type::difference_type difference_type; - const_element_proxy () : mPtr () { } - explicit const_element_proxy (proxy_type *ptr) : mPtr (ptr) { } - const_element_proxy (proxy_pointer const &ptr) : mPtr (ptr) { } + const_element_proxy () : m_ptr () { } + explicit const_element_proxy (proxy_type *ptr) : m_ptr (ptr) { } + const_element_proxy (proxy_pointer const &ptr) : m_ptr (ptr) { } const_element_proxy (element_proxy const ©) - : mPtr (copy.mPtr) + : m_ptr (copy.m_ptr) { } explicit const_element_proxy (raw_value_type const &val) - : mPtr (new proxy_type(val)) + : m_ptr (new proxy_type(val)) { // Create new standalone value (i.e. detached) } - reference operator* () const { return mPtr->operator*(); } - pointer operator-> () const { return mPtr->operator->(); } + reference operator* () const { return m_ptr->operator*(); } + pointer operator-> () const { return m_ptr->operator->(); } // Implicit conversion to raw_value_type operator reference () const { return operator*(); } - size_t use_count() const { return mPtr.use_count(); } // For debugging + size_t use_count() const { return m_ptr.use_count(); } // For debugging }; } } } diff --git a/include/boost/python/suite/indexing/int_slice_helper.hpp b/include/boost/python/suite/indexing/int_slice_helper.hpp index ed81fdee..74e7c322 100755 --- a/include/boost/python/suite/indexing/int_slice_helper.hpp +++ b/include/boost/python/suite/indexing/int_slice_helper.hpp @@ -49,17 +49,17 @@ namespace boost { namespace python { namespace indexing { void insert (value_param val); private: - slice_type mSlice; - container *mPtr; - index_type mPos; + slice_type m_slice; + container *m_ptr; + index_type m_pos; }; template int_slice_helper ::int_slice_helper (container &c, slice_type const &sl) - : mSlice (sl) - , mPtr (&c) - , mPos (-1) + : m_slice (sl) + , m_ptr (&c) + , m_pos (-1) { } @@ -69,18 +69,18 @@ namespace boost { namespace python { namespace indexing { { bool result = false; // Assume the worst - if (mPos == -1) + if (m_pos == -1) { // First time call - get to start of the slice (if any) - mPos = mSlice.start(); - result = mSlice.in_range (mPos); + m_pos = m_slice.start(); + result = m_slice.in_range (m_pos); } - else if (mSlice.in_range (mPos)) + else if (m_slice.in_range (m_pos)) { // Subsequent calls - advance by the slice's stride - mPos += mSlice.step(); - result = mSlice.in_range (mPos); + m_pos += m_slice.step(); + result = m_slice.in_range (m_pos); } return result; @@ -90,7 +90,7 @@ namespace boost { namespace python { namespace indexing { typename int_slice_helper::reference int_slice_helper::current () const { - return algorithms::get (*mPtr, mPos); + return algorithms::get (*m_ptr, m_pos); } template @@ -110,7 +110,7 @@ namespace boost { namespace python { namespace indexing { template void int_slice_helper::assign (value_param val) const { - algorithms::assign (*mPtr, mPos, val); + algorithms::assign (*m_ptr, m_pos, val); } namespace detail { @@ -141,7 +141,7 @@ namespace boost { namespace python { namespace indexing { template void int_slice_helper::insert (value_param val) { - if (mSlice.step() != 1) + if (m_slice.step() != 1) { PyErr_SetString (PyExc_ValueError , "attempt to insert via extended slice"); @@ -152,9 +152,9 @@ namespace boost { namespace python { namespace indexing { else { detail::maybe_insert - ::template apply (*mPtr, mPos, val); + ::template apply (*m_ptr, m_pos, val); - ++mPos; // Advance for any subsequent inserts + ++m_pos; // Advance for any subsequent inserts } } @@ -186,7 +186,7 @@ namespace boost { namespace python { namespace indexing { template void int_slice_helper::erase_remaining () const { - if (mSlice.step() != 1) + if (m_slice.step() != 1) { PyErr_SetString (PyExc_ValueError , "attempt to delete via extended slice"); @@ -197,7 +197,7 @@ namespace boost { namespace python { namespace indexing { else { detail::maybe_erase - ::template apply (*mPtr, mPos, mSlice.stop()); + ::template apply (*m_ptr, m_pos, m_slice.stop()); } } } } } diff --git a/include/boost/python/suite/indexing/iterator_pair.hpp b/include/boost/python/suite/indexing/iterator_pair.hpp index f7289c98..8dcfcdb7 100755 --- a/include/boost/python/suite/indexing/iterator_pair.hpp +++ b/include/boost/python/suite/indexing/iterator_pair.hpp @@ -62,23 +62,23 @@ namespace boost { namespace python { namespace indexing { reference at (size_type) const; private: - iterator myBegin; - iterator myEnd; + iterator m_begin; + iterator m_end; }; template iterator_pair::iterator_pair (iterator_param begin , iterator_param end) - : myBegin (begin) - , myEnd (end) + : m_begin (begin) + , m_end (end) { } template iterator_pair ::iterator_pair (std::pair const &pair) - : myBegin (pair.first) - , myEnd (pair.second) + : m_begin (pair.first) + , m_end (pair.second) { } @@ -86,14 +86,14 @@ namespace boost { namespace python { namespace indexing { typename iterator_pair::iterator iterator_pair::begin() const { - return myBegin; + return m_begin; } template typename iterator_pair::iterator iterator_pair::end() const { - return myEnd; + return m_end; } template diff --git a/include/boost/python/suite/indexing/python_iterator.hpp b/include/boost/python/suite/indexing/python_iterator.hpp index 69e0d77b..84d9b1a1 100755 --- a/include/boost/python/suite/indexing/python_iterator.hpp +++ b/include/boost/python/suite/indexing/python_iterator.hpp @@ -46,9 +46,9 @@ namespace boost { namespace python { namespace indexing { virtual boost::python::object current() const; private: - boost::python::object mGetitemMethod; - int mIndex; - boost::python::object mCurrent; + boost::python::object m_getitem_method; + int m_index; + boost::python::object m_current; }; struct BOOST_PYTHON_DECL python_iter_iterator : public python_iterator @@ -59,8 +59,8 @@ namespace boost { namespace python { namespace indexing { virtual boost::python::object current() const; private: - boost::python::object mNextMethod; - boost::python::object mCurrent; + boost::python::object m_next_method; + boost::python::object m_current; }; } } } diff --git a/include/boost/python/suite/indexing/shared_proxy_impl.hpp b/include/boost/python/suite/indexing/shared_proxy_impl.hpp index 19235113..d5116ff3 100755 --- a/include/boost/python/suite/indexing/shared_proxy_impl.hpp +++ b/include/boost/python/suite/indexing/shared_proxy_impl.hpp @@ -40,8 +40,8 @@ namespace boost { namespace python { namespace indexing { reference operator*() const; pointer operator->() const { return &(**this); } - ContainerProxy *owner() const { return myOwnerPtr; } - size_t index() const { return myIndex; } + ContainerProxy *owner() const { return m_owner_ptr; } + size_t index() const { return m_index; } shared_proxy_impl (value_type const ©); // Creates value-only (detached) proxy @@ -53,9 +53,9 @@ namespace boost { namespace python { namespace indexing { void detach (); private: - ContainerProxy *myOwnerPtr; // When attached - size_t myIndex; // When attached - std::auto_ptr myElementPtr; // When detached + ContainerProxy *m_owner_ptr; // When attached + size_t m_index; // When attached + std::auto_ptr m_element_ptr; // When detached private: // Not implemented @@ -64,19 +64,19 @@ namespace boost { namespace python { namespace indexing { }; template - shared_proxy_impl::shared_proxy_impl (ContainerProxy *ownerPtr + shared_proxy_impl::shared_proxy_impl (ContainerProxy *owner , size_t index) - : myOwnerPtr (ownerPtr) - , myIndex (index) - , myElementPtr () + : m_owner_ptr (owner) + , m_index (index) + , m_element_ptr () { } template shared_proxy_impl::shared_proxy_impl (value_type const &val) - : myOwnerPtr (0) - , myIndex (static_cast(-1)) - , myElementPtr (new value_type (val)) + : m_owner_ptr (0) + , m_index (static_cast(-1)) + , m_element_ptr (new value_type (val)) { } @@ -84,17 +84,17 @@ namespace boost { namespace python { namespace indexing { typename shared_proxy_impl::reference shared_proxy_impl::operator* () const { - return myOwnerPtr - ? myOwnerPtr->raw_container().at (myIndex) - : *myElementPtr; + return m_owner_ptr + ? m_owner_ptr->raw_container().at (m_index) + : *m_element_ptr; } template void shared_proxy_impl::detach () { - myElementPtr.reset (new value_type (**this)); - myOwnerPtr = 0; - myIndex = static_cast(-1); + m_element_ptr.reset (new value_type (**this)); + m_owner_ptr = 0; + m_index = static_cast(-1); } } } } diff --git a/include/boost/python/suite/indexing/slice.hpp b/include/boost/python/suite/indexing/slice.hpp index 82d5c290..4505533e 100755 --- a/include/boost/python/suite/indexing/slice.hpp +++ b/include/boost/python/suite/indexing/slice.hpp @@ -41,24 +41,24 @@ namespace boost { namespace python { namespace indexing { typedef int index_type; - integer_slice (slice const &, index_type sequenceLength); + integer_slice (slice const &, index_type length); // integer_slice must know how big the container is so it can // adjust for negative indexes, etc... - index_type start() const { return mStart; } - index_type step() const { return mStep; } - index_type stop() const { return mStop; } + index_type start() const { return m_start; } + index_type step() const { return m_step; } + index_type stop() const { return m_stop; } - index_type size() const { return (mStop - mStart) / mStep; } + index_type size() const { return (m_stop - m_start) / m_step; } bool in_range (index_type index); private: - slice mSlice; - index_type mStart; - index_type mStep; - index_type mStop; - index_type mDirection; + slice m_slice; + index_type m_start; + index_type m_step; + index_type m_stop; + index_type m_direction; }; } } } diff --git a/include/boost/python/suite/indexing/slice_handler.hpp b/include/boost/python/suite/indexing/slice_handler.hpp index 1315e91e..0c0d7d88 100755 --- a/include/boost/python/suite/indexing/slice_handler.hpp +++ b/include/boost/python/suite/indexing/slice_handler.hpp @@ -65,7 +65,7 @@ namespace boost { namespace python { namespace indexing { PyObject* postcall (PyObject *args, PyObject *result); private: - Policy mBase; + Policy m_base; }; }; @@ -76,7 +76,7 @@ namespace boost { namespace python { namespace indexing { template slice_handler ::postcall_override::postcall_override (Policy const &p) - : mBase (p) + : m_base (p) { } @@ -89,7 +89,7 @@ namespace boost { namespace python { namespace indexing { slice_handler ::postcall_override::precall (PyObject *args) { - return mBase.precall (args); + return m_base.precall (args); } ////////////////////////////////////////////////////////////////////////// @@ -105,7 +105,7 @@ namespace boost { namespace python { namespace indexing { for (int count = 0; count < size; ++count) { - mBase.postcall (args, PyList_GetItem (result, count)); + m_base.postcall (args, PyList_GetItem (result, count)); } return result; diff --git a/include/boost/python/suite/indexing/visitor.hpp b/include/boost/python/suite/indexing/visitor.hpp index 8494de6d..8d2982fc 100755 --- a/include/boost/python/suite/indexing/visitor.hpp +++ b/include/boost/python/suite/indexing/visitor.hpp @@ -34,14 +34,14 @@ namespace boost { namespace python { namespace indexing { // except precall, which must be provided by the template // argument. - precall_only () : mPrecall () { } - explicit precall_only (PrecallPolicy const ©) : mPrecall (copy) { } + precall_only () : m_precall () { } + explicit precall_only (PrecallPolicy const ©) : m_precall (copy) { } - bool precall (PyObject *args) { return mPrecall.precall (args); } - bool precall (PyObject *args) const { return mPrecall.precall (args); } + bool precall (PyObject *args) { return m_precall.precall (args); } + bool precall (PyObject *args) const { return m_precall.precall (args); } private: - PrecallPolicy mPrecall; + PrecallPolicy m_precall; }; } @@ -453,19 +453,19 @@ namespace boost { namespace python { namespace indexing { class visitor : public boost::python::def_visitor< visitor< Algorithms, Policy > > { - Policy mPolicy; + Policy m_policy; public: typedef Algorithms algorithms; typedef typename algorithms::container_traits traits; typedef typename traits::value_traits_ value_traits_; - explicit visitor (Policy const &policy = Policy()) : mPolicy (policy) { } + explicit visitor (Policy const &policy = Policy()) : m_policy (policy) { } template void visit (PythonClass &pyClass) const { - detail::precall_only precallPolicy (mPolicy); + detail::precall_only precallPolicy (m_policy); // Note - this will add __len__ for anything that can determine // its size, even if that might be inefficient (e.g. have linear @@ -476,17 +476,17 @@ namespace boost { namespace python { namespace indexing { ::apply (pyClass, algorithms(), precallPolicy); maybe_add_getitem - ::apply (pyClass, algorithms(), mPolicy); + ::apply (pyClass, algorithms(), m_policy); maybe_add_setitem - ::apply (pyClass, algorithms(), mPolicy); + ::apply (pyClass, algorithms(), m_policy); maybe_add_delitem - ::apply (pyClass, algorithms(), mPolicy); + ::apply (pyClass, algorithms(), m_policy); maybe_add_iter<((traits::index_style != index_style_linear) && traits::has_copyable_iter)> - ::apply (pyClass, algorithms(), mPolicy); + ::apply (pyClass, algorithms(), m_policy); maybe_add_sort @@ -512,7 +512,7 @@ namespace boost { namespace python { namespace indexing { maybe_add_count ::apply (pyClass, algorithms(), precallPolicy); - Algorithms::visitor_helper (pyClass, mPolicy); + Algorithms::visitor_helper (pyClass, m_policy); } }; } } } diff --git a/src/indexing/python_iterator.cpp b/src/indexing/python_iterator.cpp index 015171a4..9bedf0db 100755 --- a/src/indexing/python_iterator.cpp +++ b/src/indexing/python_iterator.cpp @@ -63,9 +63,9 @@ boost::python::indexing::python_iterator::~python_iterator () boost::python::indexing::python_getitem_iterator ::python_getitem_iterator (boost::python::object obj) - : mGetitemMethod (obj.attr ("__getitem__")) - , mIndex (0) - , mCurrent() + : m_getitem_method (obj.attr ("__getitem__")) + , m_index (0) + , m_current() { } @@ -79,8 +79,8 @@ bool boost::python::indexing::python_getitem_iterator::next () try { - mCurrent = mGetitemMethod (mIndex); - ++mIndex; + m_current = m_getitem_method (m_index); + ++m_index; } catch (boost::python::error_already_set const &) @@ -89,7 +89,7 @@ bool boost::python::indexing::python_getitem_iterator::next () { // Eat this exception PyErr_Clear (); - mCurrent = boost::python::object (); + m_current = boost::python::object (); result = false; } @@ -110,7 +110,7 @@ bool boost::python::indexing::python_getitem_iterator::next () boost::python::object boost::python::indexing::python_getitem_iterator::current () const { - return mCurrent; + return m_current; } //////////////////////////////////////////////////////////////////////////// @@ -119,8 +119,8 @@ boost::python::indexing::python_getitem_iterator::current () const boost::python::indexing::python_iter_iterator ::python_iter_iterator (boost::python::object obj) - : mNextMethod (obj.attr ("__iter__")().attr ("next")) - , mCurrent() + : m_next_method (obj.attr ("__iter__")().attr ("next")) + , m_current() { } @@ -134,7 +134,7 @@ bool boost::python::indexing::python_iter_iterator::next () try { - mCurrent = mNextMethod (); + m_current = m_next_method (); } catch (boost::python::error_already_set const &) @@ -143,7 +143,7 @@ bool boost::python::indexing::python_iter_iterator::next () { // Eat this exception PyErr_Clear (); - mCurrent = boost::python::object (); + m_current = boost::python::object (); result = false; } @@ -164,5 +164,5 @@ bool boost::python::indexing::python_iter_iterator::next () boost::python::object boost::python::indexing::python_iter_iterator::current () const { - return mCurrent; + return m_current; } diff --git a/src/indexing/slice.cpp b/src/indexing/slice.cpp index 3835c931..96ef0b2d 100755 --- a/src/indexing/slice.cpp +++ b/src/indexing/slice.cpp @@ -32,26 +32,26 @@ boost::python::indexing::slice::slice (slice const ©) ///////////////////////////////////////////////////////////////////////////// boost::python::indexing::integer_slice -::integer_slice (slice const &sl, index_type sequenceLength) - : mSlice (sl) +::integer_slice (slice const &sl, index_type length) + : m_slice (sl) // Leave index members uninitialized { - PySlice_GetIndices (reinterpret_cast (mSlice.ptr()) - , sequenceLength - , &mStart - , &mStop - , &mStep); + PySlice_GetIndices (reinterpret_cast (m_slice.ptr()) + , length + , &m_start + , &m_stop + , &m_step); - if (mStep == 0) + if (m_step == 0) { // Can happen with Python prior to 2.3 PyErr_SetString (PyExc_ValueError, "slice step cannot be zero"); boost::python::throw_error_already_set (); } - mStart = std::max (0, std::min (sequenceLength, mStart)); - mStop = std::max (0, std::min (sequenceLength, mStop)); - mDirection = (mStep > 0) ? 1 : -1; + m_start = std::max (0, std::min (length, m_start)); + m_stop = std::max (0, std::min (length, m_stop)); + m_direction = (m_step > 0) ? 1 : -1; } ///////////////////////////////////////////////////////////////////////////// @@ -60,5 +60,5 @@ boost::python::indexing::integer_slice bool boost::python::indexing::integer_slice::in_range (index_type index) { - return ((mStop - index) * mDirection) > 0; + return ((m_stop - index) * m_direction) > 0; }