Added quantiling UDAFs

[com/gs-lite.git] / src / lib / gscpaux / block_allocator.cpp

diff --git a/src/lib/gscpaux/block_allocator.cpp b/src/lib/gscpaux/block_allocator.cpp
index 5d0fbdc..a8fa13c 100644 (file)
--- a/src/lib/gscpaux/block_allocator.cpp
+++ b/src/lib/gscpaux/block_allocator.cpp
@@ -1,52 +1,52 @@
-// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev
-
-#include <stdlib.h>
-#include <algorithm>
-#include "block_allocator.h"
-
-block_allocator::block_allocator(size_t blocksize): m_head(0), m_blocksize(blocksize)
-{
-}
-
-block_allocator::~block_allocator()
-{
-       while (m_head)
-       {
-               block *temp = m_head->next;
-               ::free(m_head);
-               m_head = temp;
-       }
-}
-
-void block_allocator::swap(block_allocator &rhs)
-{
-       std::swap(m_blocksize, rhs.m_blocksize);
-       std::swap(m_head, rhs.m_head);
-}
-
-void *block_allocator::malloc(size_t size)
-{
-       if ((m_head && m_head->used + size > m_head->size) || !m_head)
-       {
-               // calc needed size for allocation
-               size_t alloc_size = std::max(sizeof(block) + size, m_blocksize);
-
-               // create new block
-               char *buffer = (char *)::malloc(alloc_size);
-               block *b = reinterpret_cast<block *>(buffer);
-               b->size = alloc_size;
-               b->used = sizeof(block);
-               b->buffer = buffer;
-               b->next = m_head;
-               m_head = b;
-       }
-
-       void *ptr = m_head->buffer + m_head->used;
-       m_head->used += size;
-       return ptr;
-}
-
-void block_allocator::free()
-{
-       block_allocator(0).swap(*this);
-}
+// Distributed under the MIT license. Copyright (c) 2010, Ivan Vashchaev\r
+\r
+#include <stdlib.h>\r
+#include <algorithm>\r
+#include "block_allocator.h"\r
+\r
+block_allocator::block_allocator(size_t blocksize): m_head(0), m_blocksize(blocksize)\r
+{\r
+}\r
+\r
+block_allocator::~block_allocator()\r
+{\r
+       while (m_head)\r
+       {\r
+               block *temp = m_head->next;\r
+               ::free(m_head);\r
+               m_head = temp;\r
+       }\r
+}\r
+\r
+void block_allocator::swap(block_allocator &rhs)\r
+{\r
+       std::swap(m_blocksize, rhs.m_blocksize);\r
+       std::swap(m_head, rhs.m_head);\r
+}\r
+\r
+void *block_allocator::malloc(size_t size)\r
+{\r
+       if ((m_head && m_head->used + size > m_head->size) || !m_head)\r
+       {\r
+               // calc needed size for allocation\r
+               size_t alloc_size = std::max(sizeof(block) + size, m_blocksize);\r
+\r
+               // create new block\r
+               char *buffer = (char *)::malloc(alloc_size);\r
+               block *b = reinterpret_cast<block *>(buffer);\r
+               b->size = alloc_size;\r
+               b->used = sizeof(block);\r
+               b->buffer = buffer;\r
+               b->next = m_head;\r
+               m_head = b;\r
+       }\r
+\r
+       void *ptr = m_head->buffer + m_head->used;\r
+       m_head->used += size;\r
+       return ptr;\r
+}\r
+\r
+void block_allocator::free()\r
+{\r
+       block_allocator(0).swap(*this);\r
+}\r