sourcemod-central: core/CellArray.h@185cac1820fe

     1 /**

     2  * vim: set ts=4 :

     3  * =============================================================================

     4  * SourceMod

     5  * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    32 #include <malloc.h>

    33 #include <string.h>

    35 class CellArray

    36 {

    37 public:

    38 	CellArray(size_t blocksize) : m_Data(NULL), m_BlockSize(blocksize), m_AllocSize(0), m_Size(0)

    39 	{

    40 	}

    41 	~CellArray()

    42 	{

    43 		free(m_Data);

    44 	}

    45 	size_t size() const

    46 	{

    47 		return m_Size;

    48 	}

    49 	cell_t *push()

    50 	{

    51 		if (!GrowIfNeeded(1))

    52 		{

    53 			return NULL;

    54 		}

    55 		cell_t *arr = &m_Data[m_Size * m_BlockSize];

    56 		m_Size++;

    57 		return arr;

    58 	}

    59 	cell_t *at(size_t b) const

    60 	{

    61 		return &m_Data[b * m_BlockSize];

    62 	}

    63 	size_t blocksize() const

    64 	{

    65 		return m_BlockSize;

    66 	}

    67 	void clear()

    68 	{

    69 		m_Size = 0;

    70 	}

    71 	bool swap(size_t item1, size_t item2)

    72 	{

    73 		/* Make sure there is extra space available */

    74 		if (!GrowIfNeeded(1))

    75 		{

    76 			return false;

    77 		}

    79 		cell_t *pri = at(item1);

    80 		cell_t *alt = at(item2);

    82 		/* Get our temporary array 1 after the limit */

    83 		cell_t *temp = &m_Data[m_Size * m_BlockSize];

    85 		memcpy(temp, pri, sizeof(cell_t) * m_BlockSize);

    86 		memcpy(pri, alt, sizeof(cell_t) * m_BlockSize);

    87 		memcpy(alt, temp, sizeof(cell_t) * m_BlockSize);

    89 		return true;

    90 	}

    91 	void remove(size_t index)

    92 	{

    93 		/* If we're at the end, take the easy way out */

    94 		if (index == m_Size - 1)

    95 		{

    96 			m_Size--;

    97 			return;

    98 		}

   100 		/* Otherwise, it's time to move stuff! */

   101 		size_t remaining_indexes = (m_Size - 1) - index;

   102 		cell_t *src = at(index + 1);

   103 		cell_t *dest = at(index);

   104 		memmove(dest, src, sizeof(cell_t) * m_BlockSize * remaining_indexes);

   106 		m_Size--;

   107 	}

   108 	cell_t *insert_at(size_t index)

   109 	{

   110 		/* Make sure it'll fit */

   111 		if (!GrowIfNeeded(1))

   112 		{

   113 			return NULL;

   114 		}

   116 		/* move everything up */

   117 		cell_t *src = at(index);

   118 		cell_t *dst = at(index + 1);

   119 		memmove(dst, src, sizeof(cell_t) * m_BlockSize * m_Size);

   121 		m_Size++;

   123 		return src;

   124 	}

   125 	bool resize(size_t count)

   126 	{

   127 		if (count <= m_Size)

   128 		{

   129 			m_Size = count;

   130 			return true;

   131 		}

   133 		if(!GrowIfNeeded(count - m_Size))

   134 		{

   135 			return false;

   136 		}

   138 		m_Size = count;

   139 		return true;

   140 	}

   142 	CellArray *clone()

   143 	{

   144 		CellArray *array = new CellArray(m_BlockSize);

   145 		array->m_AllocSize = m_AllocSize;

   146 		array->m_Size = m_Size;

   147 		array->m_Data = (cell_t *)malloc(sizeof(cell_t) * m_BlockSize * m_AllocSize);

   148 		memcpy(array->m_Data, m_Data, sizeof(cell_t) * m_BlockSize * m_Size);

   149 		return array;

   150 	}

   152 private:

   153 	bool GrowIfNeeded(size_t count)

   154 	{

   155 		/* Shortcut out if we can store this */

   156 		if (m_Size + count <= m_AllocSize)

   157 		{

   158 			return true;

   159 		}

   160 		/* Set a base allocation size of 8 items */

   161 		if (!m_AllocSize)

   162 		{

   163 			m_AllocSize = 8;

   164 		}

   165 		/* If it's not enough, keep doubling */

   166 		while (m_Size + count > m_AllocSize)

   167 		{

   168 			m_AllocSize *= 2;

   169 		}

   170 		/* finally, allocate the new block */

   171 		if (m_Data)

   172 		{

   173 			m_Data = (cell_t *)realloc(m_Data, sizeof(cell_t) * m_BlockSize * m_AllocSize);

   174 		} else {

   175 			m_Data = (cell_t *)malloc(sizeof(cell_t) * m_BlockSize * m_AllocSize);

   176 		}

   177 		return (m_Data != NULL);

   178 	}

   179 private:

   180 	cell_t *m_Data;

   181 	size_t m_BlockSize;

   182 	size_t m_AllocSize;

   183 	size_t m_Size;

   184 };

author	Borja Ferrer <faluco@alliedmods.net>
	Fri Nov 16 21:34:29 2007 +0000 (2007-11-16)
changeset 1686	185cac1820fe
parent 1664	e054be79e28a
child 1701	9cf7f48da853
permissions	-rw-r--r--