Imported Healpix, cfitsio, cosmotool. Added cmake tool to build dependencies (cfitsio, hdf5, netcdf, boost, healpix, gsl, ..). Adjusted CMakeLists.txt

external/cosmotool/src/pool.hpp

@@ -0,0 +1,166 @@
+#ifndef __COSMO_POOL_HPP
+#define __COSMO_POOL_HPP
+
+#include <list>
+#include "config.hpp"
+
+namespace CosmoTool
+{
+
+  template<typename T>
+  struct PoolNode
+  {
+    T *data;
+    uint32_t last_free, size;
+    PoolNode<T> *next;
+  };
+
+  template<typename T> class MemoryPool;
+
+  template<typename T>
+  class MemoryIterator
+  {
+  private:
+    friend  class MemoryPool<T>;
+
+    PoolNode<T> *cur, *previous;
+    uint32_t in_node;
+
+    MemoryIterator(PoolNode<T> *h) 
+    {
+      cur = h; 
+      previous = h; 
+      in_node = 0;
+    }
+  public:
+    MemoryIterator() { cur = 0; }
+    ~MemoryIterator() {}
+
+    const MemoryIterator& operator=(const MemoryIterator& i)
+    {
+      cur = i.cur;
+      previous = i.previous;
+      in_node = i.in_node;
+    }
+    
+    bool operator==(const MemoryIterator& i) const
+    {
+      return (cur == i.cur) && (in_node == i.in_node);
+    }
+
+    MemoryIterator& operator++()
+    {
+      if (cur == 0)
+	return *this;
+
+      in_node++;
+      if (in_node == cur->size)
+	{
+	  in_node = 0;
+	  previous = cur;
+	  cur = cur->next;
+	}
+      return *this;
+    }
+
+    T& operator*()
+    {
+      return cur->data[in_node];
+    }
+
+    T& operator->()
+    {
+      return cur->data[in_node];
+    }
+
+    
+    
+  };
+
+  // This is bare simple memory pools
+  template<typename T>
+  class MemoryPool
+  {
+  private:
+    uint32_t m_allocSize;
+    PoolNode<T> *head, *current;
+    typedef MemoryIterator<T> iterator;
+  public:
+    MemoryPool(uint32_t allocSize)
+      : m_allocSize(allocSize), head(0), current(0) {}
+
+    ~MemoryPool()
+    {
+      free_all();
+    }
+
+    void free_all()
+    {
+      PoolNode<T> *node = head;
+
+      while (node != 0)
+	{
+	  PoolNode<T> *next = node->next;
+	  	  
+	  delete[] node->data;
+	  delete node;
+	  node = next;
+	}
+      current = head = 0;
+    }
+
+    T *alloc()
+    {
+      T *ret = alloc_in_node();
+      return (ret == 0) ? alloc_new_in_node() : ret;
+    }
+    
+    iterator begin()
+    {
+      return iterator(head);
+    }
+    
+    iterator end()
+    {
+      return iterator(0);
+    }    
+
+  protected:
+    T *alloc_in_node()
+    {
+      if (current == 0 || current->last_free == current->size)
+	return 0;
+      return &current->data[current->last_free++];
+    }
+
+    T *alloc_new_in_node()
+    {
+      PoolNode<T> *newNode = new PoolNode<T>;
+      if (newNode == 0)
+	return 0;
+
+      newNode->last_free = 1;
+      newNode->size = m_allocSize;
+      newNode->data = new T[m_allocSize];
+      if (newNode->data == 0)
+	{
+	  delete newNode;
+	  return 0;
+	}
+      newNode->next = 0;
+
+      if (current == 0)
+	current = head = newNode;
+      else
+	{
+	  current->next = newNode;
+	  current = newNode;
+	}
+      return &newNode->data[0];
+    }
+
+  };
+  
+};
+
+#endif