Replace tabs with spaces (to pass style check)

tests/object.h

@@ -13,32 +13,32 @@ public:
     /// Copy constructor
     Object(const Object &) : m_refCount(0) { print_copy_created(this); }
 
-	/// Return the current reference count
+    /// Return the current reference count
-	int getRefCount() const { return m_refCount; };
+    int getRefCount() const { return m_refCount; };
 
-	/// Increase the object's reference count by one
+    /// Increase the object's reference count by one
-	void incRef() const { ++m_refCount; }
+    void incRef() const { ++m_refCount; }
 
-	/** \brief Decrease the reference count of
+    /** \brief Decrease the reference count of
-	 * the object and possibly deallocate it.
+     * the object and possibly deallocate it.
-	 *
+     *
-	 * The object will automatically be deallocated once
+     * The object will automatically be deallocated once
-	 * the reference count reaches zero.
+     * the reference count reaches zero.
-	 */
+     */
-	void decRef(bool dealloc = true) const {
+    void decRef(bool dealloc = true) const {
-	    --m_refCount;
+        --m_refCount;
-	    if (m_refCount == 0 && dealloc)
+        if (m_refCount == 0 && dealloc)
             delete this;
         else if (m_refCount < 0)
-	        throw std::runtime_error("Internal error: reference count < 0!");
+            throw std::runtime_error("Internal error: reference count < 0!");
     }
 
     virtual std::string toString() const = 0;
 protected:
-	/** \brief Virtual protected deconstructor.
+    /** \brief Virtual protected deconstructor.
-	 * (Will only be called by \ref ref)
+     * (Will only be called by \ref ref)
-	 */
+     */
-	virtual ~Object() { print_destroyed(this); }
+    virtual ~Object() { print_destroyed(this); }
 private:
     mutable std::atomic<int> m_refCount { 0 };
 };
@@ -61,18 +61,18 @@ class ref_tag {};
  */
 template <typename T> class ref {
 public:
-	/// Create a nullptr reference
+    /// Create a nullptr reference
     ref() : m_ptr(nullptr) { print_default_created(this); track_default_created((ref_tag*) this); }
 
     /// Construct a reference from a pointer
-	ref(T *ptr) : m_ptr(ptr) {
+    ref(T *ptr) : m_ptr(ptr) {
-	    if (m_ptr) ((Object *) m_ptr)->incRef();
+        if (m_ptr) ((Object *) m_ptr)->incRef();
 
         print_created(this, "from pointer", m_ptr); track_created((ref_tag*) this, "from pointer");
 
-	}
+    }
 
-	/// Copy constructor
+    /// Copy constructor
     ref(const ref &r) : m_ptr(r.m_ptr) {
         if (m_ptr)
             ((Object *) m_ptr)->incRef();
@@ -96,80 +96,80 @@ public:
     }
 
     /// Move another reference into the current one
-	ref& operator=(ref&& r) {
+    ref& operator=(ref&& r) {
         print_move_assigned(this, "pointer", r.m_ptr); track_move_assigned((ref_tag*) this);
 
-		if (*this == r)
+        if (*this == r)
-			return *this;
+            return *this;
-		if (m_ptr)
+        if (m_ptr)
-			((Object *) m_ptr)->decRef();
+            ((Object *) m_ptr)->decRef();
-		m_ptr = r.m_ptr;
+        m_ptr = r.m_ptr;
-		r.m_ptr = nullptr;
+        r.m_ptr = nullptr;
-		return *this;
+        return *this;
-	}
+    }
 
-	/// Overwrite this reference with another reference
+    /// Overwrite this reference with another reference
-	ref& operator=(const ref& r) {
+    ref& operator=(const ref& r) {
         print_copy_assigned(this, "pointer", r.m_ptr); track_copy_assigned((ref_tag*) this);
 
-		if (m_ptr == r.m_ptr)
+        if (m_ptr == r.m_ptr)
-			return *this;
+            return *this;
-		if (m_ptr)
+        if (m_ptr)
-			((Object *) m_ptr)->decRef();
+            ((Object *) m_ptr)->decRef();
-		m_ptr = r.m_ptr;
+        m_ptr = r.m_ptr;
-		if (m_ptr)
+        if (m_ptr)
-			((Object *) m_ptr)->incRef();
+            ((Object *) m_ptr)->incRef();
-		return *this;
+        return *this;
-	}
+    }
 
-	/// Overwrite this reference with a pointer to another object
+    /// Overwrite this reference with a pointer to another object
-	ref& operator=(T *ptr) {
+    ref& operator=(T *ptr) {
         print_values(this, "assigned pointer"); track_values((ref_tag*) this, "assigned pointer");
 
-		if (m_ptr == ptr)
+        if (m_ptr == ptr)
-			return *this;
+            return *this;
-		if (m_ptr)
+        if (m_ptr)
-			((Object *) m_ptr)->decRef();
+            ((Object *) m_ptr)->decRef();
-		m_ptr = ptr;
+        m_ptr = ptr;
-		if (m_ptr)
+        if (m_ptr)
-			((Object *) m_ptr)->incRef();
+            ((Object *) m_ptr)->incRef();
-		return *this;
+        return *this;
-	}
+    }
 
-	/// Compare this reference with another reference
+    /// Compare this reference with another reference
-	bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
+    bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
 
-	/// Compare this reference with another reference
+    /// Compare this reference with another reference
-	bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
+    bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
 
-	/// Compare this reference with a pointer
+    /// Compare this reference with a pointer
-	bool operator==(const T* ptr) const { return m_ptr == ptr; }
+    bool operator==(const T* ptr) const { return m_ptr == ptr; }
 
-	/// Compare this reference with a pointer
+    /// Compare this reference with a pointer
-	bool operator!=(const T* ptr) const { return m_ptr != ptr; }
+    bool operator!=(const T* ptr) const { return m_ptr != ptr; }
 
-	/// Access the object referenced by this reference
+    /// Access the object referenced by this reference
-	T* operator->() { return m_ptr; }
+    T* operator->() { return m_ptr; }
 
-	/// Access the object referenced by this reference
+    /// Access the object referenced by this reference
-	const T* operator->() const { return m_ptr; }
+    const T* operator->() const { return m_ptr; }
 
-	/// Return a C++ reference to the referenced object
+    /// Return a C++ reference to the referenced object
-	T& operator*() { return *m_ptr; }
+    T& operator*() { return *m_ptr; }
 
-	/// Return a const C++ reference to the referenced object
+    /// Return a const C++ reference to the referenced object
-	const T& operator*() const { return *m_ptr; }
+    const T& operator*() const { return *m_ptr; }
 
-	/// Return a pointer to the referenced object
+    /// Return a pointer to the referenced object
-	operator T* () { return m_ptr; }
+    operator T* () { return m_ptr; }
 
-	/// Return a const pointer to the referenced object
+    /// Return a const pointer to the referenced object
-	T* get() { return m_ptr; }
+    T* get() { return m_ptr; }
 
-	/// Return a pointer to the referenced object
+    /// Return a pointer to the referenced object
-	const T* get() const { return m_ptr; }
+    const T* get() const { return m_ptr; }
 private:
-	T *m_ptr;
+    T *m_ptr;
 };
 
 #endif /* __OBJECT_H */

tests/test_stl_binders.cpp

@@ -13,25 +13,25 @@
 
 class El {
 public:
-	El() = delete;
+    El() = delete;
-	El(int v) : a(v) { }
+    El(int v) : a(v) { }
 
-	int a;
+    int a;
 };
 
 std::ostream & operator<<(std::ostream &s, El const&v) {
-	s << "El{" << v.a << '}';
+    s << "El{" << v.a << '}';
-	return s;
+    return s;
 }
 
 void init_ex_stl_binder_vector(py::module &m) {
-	py::class_<El>(m, "El")
+    py::class_<El>(m, "El")
-		.def(py::init<int>());
+        .def(py::init<int>());
 
-	py::bind_vector<unsigned int>(m, "VectorInt");
+    py::bind_vector<unsigned int>(m, "VectorInt");
-	py::bind_vector<bool>(m, "VectorBool");
+    py::bind_vector<bool>(m, "VectorBool");
 
-	py::bind_vector<El>(m, "VectorEl");
+    py::bind_vector<El>(m, "VectorEl");
 
     py::bind_vector<std::vector<El>>(m, "VectorVectorEl");
 }