From c27a19e3d1441f8baf264c4f9b1dd54a5f7b6d3f Mon Sep 17 00:00:00 2001
From: cignoni <paolo.cignoni@isti.cnr.it>
Date: Thu, 10 Sep 2015 15:09:18 +0000
Subject: [PATCH] register is deprecated

---
 vcg/space/index/kdtree/priorityqueue.h | 216 ++++++++++++-------------
 1 file changed, 108 insertions(+), 108 deletions(-)

diff --git a/vcg/space/index/kdtree/priorityqueue.h b/vcg/space/index/kdtree/priorityqueue.h
index b5bf1c38..f5bf5a80 100755
--- a/vcg/space/index/kdtree/priorityqueue.h
+++ b/vcg/space/index/kdtree/priorityqueue.h
@@ -28,135 +28,135 @@
 
 namespace vcg {
 
-	/** Implements a bounded-size max priority queue using a heap
-	*/
-	template <typename Index, typename Weight>
-	class HeapMaxPriorityQueue
-	{
-		struct Element
-		{
-			Weight weight;
-			Index index;
-		};
+  /** Implements a bounded-size max priority queue using a heap
+  */
+  template <typename Index, typename Weight>
+  class HeapMaxPriorityQueue
+  {
+    struct Element
+    {
+      Weight weight;
+      Index index;
+    };
 
 
-		struct 
-		{
-			bool operator()(const Element& a, const Element& b) const
-			{   
-				return a.weight < b.weight;
-			}   
-		} lessElement;
+    struct
+    {
+      bool operator()(const Element& a, const Element& b) const
+      {
+        return a.weight < b.weight;
+      }
+    } lessElement;
 
 
-		struct 
-		{
-			bool operator()(const Element& a, const Element& b) const
-			{   
-				return a.weight > b.weight;
-			}   
-		} greaterElement;
+    struct
+    {
+      bool operator()(const Element& a, const Element& b) const
+      {
+        return a.weight > b.weight;
+      }
+    } greaterElement;
 
 
 
-	public:
+  public:
 
-		HeapMaxPriorityQueue(void)
-		{
-			mElements = 0;
-			mMaxSize = 0;
-		}
+    HeapMaxPriorityQueue(void)
+    {
+      mElements = 0;
+      mMaxSize = 0;
+    }
 
-		~HeapMaxPriorityQueue()
-		{
-			if (mElements)
-				delete[] mElements;
-		}
+    ~HeapMaxPriorityQueue()
+    {
+      if (mElements)
+        delete[] mElements;
+    }
 
 
-		inline void setMaxSize(int maxSize)
-		{
-			if (mMaxSize!=maxSize)
-			{
-				mMaxSize = maxSize;
-				delete[] mElements;
-				mElements = new Element[mMaxSize];
-				mpOffsetedElements = (mElements-1);
-			}
-			init();
-		}
+    inline void setMaxSize(int maxSize)
+    {
+      if (mMaxSize!=maxSize)
+      {
+        mMaxSize = maxSize;
+        delete[] mElements;
+        mElements = new Element[mMaxSize];
+        mpOffsetedElements = (mElements-1);
+      }
+      init();
+    }
 
-		inline void init() { mCount = 0; }
+    inline void init() { mCount = 0; }
 
-		inline bool isFull() const { return mCount == mMaxSize; }
+    inline bool isFull() const { return mCount == mMaxSize; }
 
-		/** returns number of elements inserted in queue
-		*/
-		inline int getNofElements() const { return mCount; }
+    /** returns number of elements inserted in queue
+    */
+    inline int getNofElements() const { return mCount; }
 
-		inline Weight getWeight(int i) const { return mElements[i].weight; }
-		inline Index  getIndex(int i) const { return mElements[i].index; }
+    inline Weight getWeight(int i) const { return mElements[i].weight; }
+    inline Index  getIndex(int i) const { return mElements[i].index; }
 
-		inline Weight getTopWeight() const { return mElements[0].weight; }
+    inline Weight getTopWeight() const { return mElements[0].weight; }
 
-		inline void insert(Index index, Weight weight)
-		{
-			if (mCount==mMaxSize)
-			{
-				if (weight<mElements[0].weight)
-				{
-					register int j, k;
-					j = 1;
-					k = 2;
-					while (k <= mMaxSize)
-					{
-						Element* z = &(mpOffsetedElements[k]);
-						if ((k < mMaxSize) && (z->weight < mpOffsetedElements[k+1].weight))
-							z = &(mpOffsetedElements[++k]);
+    inline void insert(Index index, Weight weight)
+    {
+      if (mCount==mMaxSize)
+      {
+        if (weight<mElements[0].weight)
+        {
+          int j, k;
+          j = 1;
+          k = 2;
+          while (k <= mMaxSize)
+          {
+            Element* z = &(mpOffsetedElements[k]);
+            if ((k < mMaxSize) && (z->weight < mpOffsetedElements[k+1].weight))
+              z = &(mpOffsetedElements[++k]);
 
-						if(weight >= z->weight)
-							break;
-						mpOffsetedElements[j] = *z;
-						j = k;
-						k = 2 * j;
-					}
-					mpOffsetedElements[j].weight = weight;
-					mpOffsetedElements[j].index = index;
-				}
-			}
-			else
-			{
-				int i, j;
-				i = ++mCount;
-				while (i >= 2)
-				{
-					j = i >> 1;
-					Element& y = mpOffsetedElements[j];
-					if(weight <= y.weight)
-						break;
-					mpOffsetedElements[i] = y;
-					i = j;
-				}
-				mpOffsetedElements[i].index = index;
-				mpOffsetedElements[i].weight = weight;
-			}
-		}
+            if(weight >= z->weight)
+              break;
+            mpOffsetedElements[j] = *z;
+            j = k;
+            k = 2 * j;
+          }
+          mpOffsetedElements[j].weight = weight;
+          mpOffsetedElements[j].index = index;
+        }
+      }
+      else
+      {
+        int i, j;
+        i = ++mCount;
+        while (i >= 2)
+        {
+          j = i >> 1;
+          Element& y = mpOffsetedElements[j];
+          if(weight <= y.weight)
+            break;
+          mpOffsetedElements[i] = y;
+          i = j;
+        }
+        mpOffsetedElements[i].index = index;
+        mpOffsetedElements[i].weight = weight;
+      }
+    }
 
-		inline void sort(bool ascending = true)
-		{
-			if (ascending)
-				std::sort(mElements, mElements + mCount, lessElement);
-			else
-				std::sort(mElements, mElements + mCount, greaterElement);
-		}
+    inline void sort(bool ascending = true)
+    {
+      if (ascending)
+        std::sort(mElements, mElements + mCount, lessElement);
+      else
+        std::sort(mElements, mElements + mCount, greaterElement);
+    }
 
-	protected:
+  protected:
 
-		int mCount;
-		int mMaxSize;
-		Element* mElements;
-		Element* mpOffsetedElements;
-	};
+    int mCount;
+    int mMaxSize;
+    Element* mElements;
+    Element* mpOffsetedElements;
+  };
 
 }
 #endif