Add iterators natives

amxmodx/meta_api.cpp

@@ -414,6 +414,7 @@ int	C_Spawn(edict_t *pent)
 	VectorHolder.clear();
 
 	g_TrieHandles.clear();
+	g_TrieSnapshotHandles.clear();
 	g_DataPackHandles.clear();
 
 	char map_pluginsfile_path[256];

amxmodx/msvc10/amxmodx_mm.vcxproj

@@ -389,6 +389,7 @@
     <ClInclude Include="..\sh_list.h" />
     <ClInclude Include="..\sh_stack.h" />
     <ClInclude Include="..\sh_tinyhash.h" />
+    <ClInclude Include="..\sm_memtable.h" />
     <ClInclude Include="..\sm_stringhashmap.h" />
     <ClInclude Include="..\svn_version.h" />
     <ClInclude Include="..\trie_natives.h" />

amxmodx/msvc10/amxmodx_mm.vcxproj.filters

@@ -326,6 +326,9 @@
     <ClInclude Include="..\sm_stringhashmap.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\sm_memtable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\version.rc">

amxmodx/sm_memtable.h

@@ -0,0 +1,170 @@
+/**
+ * vim: set ts=4 sw=4 tw=99 noet :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_
+#define _INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+class BaseMemTable
+{
+public:
+	BaseMemTable(unsigned int init_size)
+	{
+		membase = (unsigned char *)malloc(init_size);
+		size = init_size;
+		tail = 0;
+	}
+	~BaseMemTable()
+	{
+		free(membase);
+		membase = NULL;
+	}
+public:
+	/**
+	 * Allocates 'size' bytes of memory.
+	 * Optionally outputs the address through 'addr'.
+	 * Returns an index >= 0 on success, < 0 on failure.
+	 */
+	int CreateMem(unsigned int addsize, void **addr)
+	{
+		int idx = (int)tail;
+
+		while (tail + addsize >= size) {
+			size *= 2;
+			membase = (unsigned char *)realloc(membase, size);
+		}
+
+		tail += addsize;
+		if (addr)
+			*addr = (void *)&membase[idx];
+
+		return idx;
+	}
+
+	/**
+	 * Given an index into the memory table, returns its address.
+	 * Returns NULL if invalid.
+	 */
+	void *GetAddress(int index)
+	{
+		if (index < 0 || (unsigned int)index >= tail)
+			return NULL;
+		return &membase[index];
+	}
+
+	/**
+	 * Scraps the memory table.  For caching purposes, the memory 
+	 * is not freed, however subsequent calls to CreateMem() will 
+	 * begin at the first index again.
+	 */
+	void Reset()
+	{
+		tail = 0;
+	}
+
+	inline unsigned int GetMemUsage()
+	{
+		return size;
+	}
+
+	inline unsigned int GetActualMemUsed()
+	{
+		return tail;
+	}
+
+private:
+	unsigned char *membase;
+	unsigned int size;
+	unsigned int tail;
+};
+
+class BaseStringTable
+{
+public:
+	BaseStringTable(unsigned int init_size) : m_table(init_size)
+	{
+	}
+public:
+	/** 
+	 * Adds a string to the string table and returns its index.
+	 */
+	int AddString(const char *string)
+	{
+		return AddString(string, strlen(string));
+	}
+
+	/** 
+	 * Adds a string to the string table and returns its index.
+	 */
+	int AddString(const char *string, size_t length)
+	{
+		size_t len = length + 1;
+		int idx;
+		char *addr;
+
+		idx = m_table.CreateMem(len, (void **)&addr);
+		memcpy(addr, string, length + 1);
+		return idx;
+	}
+
+	/**
+	 * Given an index into the string table, returns the associated string.
+	 */
+	inline const char *GetString(int str)
+	{
+		return (const char *)m_table.GetAddress(str);
+	}
+
+	/**
+	 * Scraps the string table. For caching purposes, the memory
+	 * is not freed, however subsequent calls to AddString() will 
+	 * begin at the first index again.
+	 */
+	void Reset()
+	{
+		m_table.Reset();
+	}
+
+	/**
+	 * Returns the parent BaseMemTable that this string table uses.
+	 */
+	inline BaseMemTable *GetMemTable()
+	{
+		return &m_table;
+	}
+private:
+	BaseMemTable m_table;
+};
+
+#endif //_INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_
+

amxmodx/trie_natives.cpp

@@ -9,6 +9,7 @@
 using namespace SourceMod;
 
 TrieHandles<CellTrie> g_TrieHandles;
+TrieHandles<TrieSnapshot> g_TrieSnapshotHandles;
 
 // native Trie:TrieCreate();
 static cell AMX_NATIVE_CALL TrieCreate(AMX *amx, cell *params)
@@ -304,6 +305,7 @@ static cell AMX_NATIVE_CALL TrieDeleteKey(AMX *amx, cell *params)
 
 	return 1;
 }
+
 //native TrieDestroy(&Trie:handle)
 static cell AMX_NATIVE_CALL TrieDestroy(AMX *amx, cell *params)
 {
@@ -339,6 +341,108 @@ static cell AMX_NATIVE_CALL TrieGetSize(AMX *amx, cell *params)
 	return t->map.elements();
 }
 
+static cell AMX_NATIVE_CALL TrieSnapshotCreate(AMX *amx, cell *params)
+{
+	CellTrie *t = g_TrieHandles.lookup(params[1]);
+
+	if (t == NULL)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid map handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	int index = g_TrieSnapshotHandles.create();
+	TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(index);
+	snapshot->length = t->map.elements();
+	snapshot->keys = new int[snapshot->length];
+
+	size_t i = 0;
+	for (StringHashMap<Entry>::iterator iter = t->map.iter(); !iter.empty(); iter.next(), i++)
+	{
+		snapshot->keys[i] = snapshot->strings.AddString(iter->key.chars(), iter->key.length());
+	}
+	assert(i == snapshot->length);
+
+	return static_cast<cell>(index);
+}
+
+static cell AMX_NATIVE_CALL TrieSnapshotLength(AMX *amx, cell *params)
+{
+	TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
+
+	if (snapshot == NULL)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	return snapshot->length;
+}
+
+static cell AMX_NATIVE_CALL TrieSnapshotKeyBufferSize(AMX *amx, cell *params)
+{
+	TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
+
+	if (snapshot == NULL)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	unsigned index = params[2];
+
+	if (index >= snapshot->length)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d", index);
+		return 0;
+	}
+
+	return strlen(snapshot->strings.GetString(snapshot->keys[index])) + 1;
+}
+
+static cell AMX_NATIVE_CALL TrieSnapshotGetKey(AMX *amx, cell *params)
+{
+	TrieSnapshot *snapshot = g_TrieSnapshotHandles.lookup(params[1]);
+
+	if (snapshot == NULL)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid snapshot handle provided (%d)", params[1]);
+		return 0;
+	}
+
+	unsigned index = params[2];
+
+	if (index >= snapshot->length)
+	{
+		LogError(amx, AMX_ERR_NATIVE, "Invalid index %d", index);
+		return 0;
+	}
+
+	const char *str = snapshot->strings.GetString(snapshot->keys[index]);
+	return set_amxstring_utf8(amx, params[3], str, strlen(str), params[4] + 1);
+}
+
+//native TrieSnapshotDestroy(&Snapshot:handle)
+static cell AMX_NATIVE_CALL TrieSnapshotDestroy(AMX *amx, cell *params)
+{
+	cell *ptr = get_amxaddr(amx, params[1]);
+
+	TrieSnapshot *t = g_TrieSnapshotHandles.lookup(*ptr);
+
+	if (t == NULL)
+	{
+		return 0;
+	}
+
+	if (g_TrieSnapshotHandles.destroy(*ptr))
+	{
+		*ptr = 0;
+		return 1;
+	}
+
+	return 0;
+}
+
 AMX_NATIVE_INFO trie_Natives[] =
 {
 	{ "TrieCreate",		TrieCreate },
@@ -355,9 +459,14 @@ AMX_NATIVE_INFO trie_Natives[] =
 	{ "TrieDeleteKey",	TrieDeleteKey },
 	{ "TrieKeyExists",	TrieKeyExists },
 	{ "TrieDestroy",	TrieDestroy },
-
 	{ "TrieGetSize",	TrieGetSize },
 
+	{ "TrieSnapshotCreate",			TrieSnapshotCreate },
+	{ "TrieSnapshotLength",			TrieSnapshotLength },
+	{ "TrieSnapshotKeyBufferSize",	TrieSnapshotKeyBufferSize },
+	{ "TrieSnapshotGetKey",			TrieSnapshotGetKey },
+	{ "TrieSnapshotDestroy",		TrieSnapshotDestroy },
+
 	{ NULL,			NULL }
 };
 

amxmodx/trie_natives.h

@@ -3,6 +3,7 @@
 
 #include "amxmodx.h"
 #include "sm_stringhashmap.h"
+#include "sm_memtable.h"
 #include "CVector.h"
 
 using namespace SourceMod;
@@ -135,6 +136,22 @@ struct CellTrie
 	StringHashMap<Entry> map;
 };
 
+struct TrieSnapshot
+{
+	TrieSnapshot()
+	: strings(128)
+	{ }
+
+	size_t mem_usage()
+	{
+		return length * sizeof(int) + strings.GetMemTable()->GetMemUsage();
+	}
+
+	size_t length;
+	ke::AutoArray<int> keys;
+	BaseStringTable strings;
+};
+
 template <typename T>
 class TrieHandles
 {
@@ -208,6 +225,7 @@ public:
 
 
 extern TrieHandles<CellTrie> g_TrieHandles;
+extern TrieHandles<TrieSnapshot> g_TrieSnapshotHandles;
 extern AMX_NATIVE_INFO trie_Natives[];
 
 #endif

plugins/include/celltrie.inc

@@ -8,6 +8,11 @@ enum Trie
 	Invalid_Trie = 0
 };
 
+enum Snapshot
+{
+	Invalid_Snapshot = 0
+};
+
 /**
  * Creates a hash map. A hash map is a container that can map strings (called
  * "keys") to arbitrary values (cells, arrays, or strings). Keys in a hash map
@@ -156,3 +161,61 @@ native TrieDestroy(&Trie:handle);
  * @error			Invalid Handle.
  */
 native TrieGetSize(Trie:handle);
+
+/**
+ * Creates a snapshot of all keys in the map. If the map is changed after this
+ * call, the changes are not reflected in the snapshot. Keys are not sorted.
+ *
+ * @param handle    Map handle.
+ *
+ * @return			New map snapshot handle, which must be freed via TrieSnapshotDestroy().
+ * @error			Invalid handle.
+ */
+native Snapshot:TrieSnapshotCreate(Trie:handle);
+
+/**
+ * Returns the number of keys in a map snapshot. Note that this may be
+ * different from the size of the map, since the map can change after the
+ * snapshot of its keys was taken.
+ *
+ * @param handle	Map snapshot.
+ *
+ * @return			Number of keys.
+ * @error			Invalid Handle.
+ */
+native TrieSnapshotLength(Snapshot:handle);
+
+/**
+ * Returns the buffer size required to store a given key. That is, it returns
+ * the length of the key plus one.
+ *
+ * @param handle	Map snapshot.
+ * @param index		Key index (starting from 0).
+ *
+ * @return 			Buffer size required to store the key string.
+ * @error			Invalid Handle or index out of range.
+ */
+native TrieSnapshotKeyBufferSize(Snapshot:handle, index);
+
+/**
+ * Retrieves the key string of a given key in a map snapshot.
+ *
+ * @param handle	Map snapshot.
+ * @param index		Key index (starting from 0).
+ * @param buffer	String buffer.
+ * @param maxlength	Maximum buffer length.
+ *
+ * @return			Number of bytes written to the buffer.
+ * @error			Invalid Handle or index out of range.
+ */
+native TrieSnapshotGetKey(Snapshot:handle, index, buffer[], maxlength);
+
+/**
+ * Destroys a Map snapshot
+ *
+ * @param handle	Map snapshot.
+ *
+ * @return			True on success, false if the value was never set.
+ * @error			Invalid Handle.
+ */
+native TrieSnapshotDestroy(&Snapshot:handle);

plugins/testsuite/trietest.sma

@@ -252,10 +252,54 @@ public trietest()
 	else
 		fail("Exists/Delete");
 
+	ok = true;
+		
 	TrieClear(t);
+
+	if (TrieGetSize(t))
+	{
+		server_print("size should be 0"); ok = false
+	}
+
+	TrieSetString(t, "adventure", "time!");
+	TrieSetString(t, "butterflies", "bees");
+	TrieSetString(t, "egg", "egg");
+
+	new Snapshot:keys = TrieSnapshotCreate(t);
+	{
+		if (TrieSnapshotLength(keys) != 3)
+		{
+			server_print("trie snapshot length should be 3"); ok = false;
+		}
+
+		new bool:found[3], len = TrieSnapshotLength(keys);
+		new buffer[32];
+		for (new i = 0; i < len; i++)
+		{
+			new size = TrieSnapshotKeyBufferSize(keys, i); // Just to use it, otherwise you should use charsmax(buffer).
+			TrieSnapshotGetKey(keys, i, buffer, size);
+
+			if (strcmp(buffer, "adventure") == 0)			found[0] = true;
+			else if (strcmp(buffer, "butterflies") == 0)	found[1] = true;
+			else if (strcmp(buffer, "egg") == 0)			found[2] = true;
+			else { server_print("unexpected key: %s", buffer); ok = false; }
+		}
+		
+		if (!found[0] || !found[1] || !found[2])
+		{
+			server_print("did not find all keys"); ok = false;
+		}
+	}
+
+	TrieSnapshotDestroy(keys);
 	TrieDestroy(t);
 	
-	done();
+	if (ok)
+		pass("Snapshot");
+	else
+		fail("Snapshot");
 
+
+	done();
 }