amxmodx/dlls/arrayx/CKeytable.h

#if !defined _JUDYSL_ENABLED_
#define _JUDYSL_ENABLED_

#define MAXLINELEN 1024

Pvoid_t MasterKeytable = (Pvoid_t) NULL;		//Create the control array

//Create an array that stores whether or not indices are used.
Pvoid_t MasterKeytable_Binary = (Pvoid_t) NULL;

void Delete_MasterKeytable(void);

Word_t New_Keytable(Word_t Index, Word_t reserve = 0);
PPvoid_t Find_Keytable(Word_t Index, Word_t disable_check = 1, AMX *amx = 0);
void Delete_Keytable(Word_t Index);
void Clear_Keytable(Word_t Index);

template <class Type>
void Keytable_Set(PPvoid_t Keytable, char *Index, Type value);

PPvoid_t Keytable_Get(AMX* amx, Pvoid_t Keytable, char *Index, int ignore_error = 0);


void Delete_MasterKeytable(void)
{
	Word_t 
		Index = 0,
		success;
	J1F(success, MasterKeytable_Binary, Index);
	while( success )
	{
		Delete_Keytable(Index);
		J1F(success, MasterKeytable_Binary, Index);
	}
}

Word_t New_Keytable(Word_t Index, Word_t reserve)
{
	Word_t success; //Dummy for macros.
	J1T(success, MasterKeytable_Binary, Index);

	if (success && reserve)
		return Index; //If the bit is set but it's 'reserved', return the index.

	//Only do this if the bit is not set or not reserved.
	J1FE(success, MasterKeytable_Binary, Index);
	J1S(success, MasterKeytable_Binary, Index);

	PPvoid_t Keytable = JudyLIns(&MasterKeytable, Index, PJE0);
	*Keytable = (PWord_t) NULL;

	return Index;
}

PPvoid_t Find_Keytable(Word_t Index, Word_t disable_check, AMX* amx)
{
	Word_t success;
	J1T(success, MasterKeytable_Binary, Index);
	if (success || disable_check)
	{ //Bit is valid
		if(!success) 
			New_Keytable(Index);

		return JudyLGet(MasterKeytable, Index, PJE0);
	}
	MF_LogError(amx, AMX_ERR_NATIVE, "Keytable \"%s\" is invalid", Index);
	return NULL;
}

void Delete_Keytable(Word_t Index)
{
	int success;
	J1T(success, MasterKeytable_Binary, Index);
	if (success)
	{ //If the bit was set, clear and delete keytable.
		Clear_Keytable(Index);
		J1U(success, MasterKeytable_Binary, Index);
		JudyLDel(&MasterKeytable, Index, PJE0);
	}
}

void Clear_Keytable(Word_t Index)
{
	int success;
	J1T(success, MasterKeytable_Binary, Index);
	if (success) //dont bother with unset Keytables.
	{
		PPvoid_t Keytable = Find_Keytable(Index);
		char *Key = "";
		PPvoid_t PValue = JudySLFirst(*Keytable, Key, PJE0);
		while (PValue != NULL)
		{
			element elem_value = *reinterpret_cast<element*>(*PValue);
			elem_value.delete_element();
			PValue = JudySLNext(*Keytable, Key, PJE0);
		}
		JudySLFreeArray(Keytable, PJE0);
	}
}


static cell AMX_NATIVE_CALL Keytable_Save(AMX *amx, cell *params)
{
	PPvoid_t Keytable = Find_Keytable(params[1], params[3], amx);
	if (Keytable == NULL) return 0;

	int filename_length;
	char *file = MF_GetAmxString(amx, params[2], 0, &filename_length);
	file = MF_BuildPathname("%s", file);
	unlink(file);
	FILE *KeytableDB = fopen(file,"w");
	if (!KeytableDB)
		return 0;
	char* Key = new char[1024]; Key[0] = '\0';
	PPvoid_t PValue = JudySLFirst(*Keytable, reinterpret_cast<uint8_t*>(Key), PJE0);
	element elem = NULL;
	char elem_type = 0;

	int error;
	
	REAL vector_data[3] = { 0.0, 0.0, 0.0 };
	while (PValue)
	{
		elem = *reinterpret_cast<element*>(*PValue);
		elem_type = elem.get_type();

		if (elem_type < elem_type_int || elem_type > elem_type_vector)
			continue;

		short key_len = strlen(Key);
		fwrite(&key_len, sizeof(short), 1, KeytableDB);
		fwrite(Key, sizeof(char), key_len, KeytableDB);
		fwrite(&elem_type, sizeof(char), 1, KeytableDB);
		if (elem_type == elem_type_int)
		{
			int int_buffer = elem.get_int(error);
			fwrite(&int_buffer, sizeof(int), 1, KeytableDB);
		}
		else if (elem_type == elem_type_real)
		{
			REAL flo_buffer = elem.get_flo(error);
			fwrite(&flo_buffer, sizeof(REAL), 1, KeytableDB);
		}
		else if (elem_type == elem_type_char)
		{
			const char* str_buffer = elem.get_str(error);
			short buf_len = strlen(str_buffer);
			fwrite(&buf_len, sizeof(short), 1, KeytableDB);
			fwrite(str_buffer, sizeof(char), buf_len, KeytableDB);
		}
		else if (elem_type == elem_type_vector)
		{
			const Vector* vec_buffer = elem.get_vec(error);
			fwrite(vec_buffer, sizeof(Vector), 1, KeytableDB);
		}
		PValue = JudySLNext(*Keytable, Key, PJE0);
	}
	fclose(KeytableDB);
	return 1;
}

static cell AMX_NATIVE_CALL Keytable_Load(AMX *amx, cell *params)
{
	//params[1]: file
	int filename_length;
	char *file = MF_GetAmxString(amx, params[1], 0, &filename_length);
	file = MF_BuildPathname("%s", file);
	FILE *KeytableDB = fopen(file, "a+");
	if (!KeytableDB)
		return 0;

	//params[2]: keytable to create (optional index supplied)
	int KeytableIndex = New_Keytable(params[2], params[3]);
	Clear_Keytable(KeytableIndex); //make sure the keytable is empty.
	PPvoid_t Keytable = Find_Keytable(KeytableIndex);
	while(!feof(KeytableDB))
	{
		char* index = ""; char type = 0; short index_len;
		element *elem_value = NULL;
		fread(&index_len, sizeof(short), 1, KeytableDB);
		index = new char[index_len+1];
		fgets(index, index_len+1, KeytableDB);
		if (feof(KeytableDB) || ferror(KeytableDB))
			break;
		fread(&type, sizeof(char), 1, KeytableDB);
		if (type < elem_type_int || type > elem_type_vector)
		{
			MF_LogError(amx, AMX_ERR_FORMAT, "Error loading keytable database \"%s\" into keytable %d. Bad file.", file, KeytableIndex);
			return KeytableIndex;
		}
		else if (type == elem_type_int)
		{
			int value = 0; fread(&value, sizeof(int), 1, KeytableDB);
			elem_value = new element(value);
		}
		else if (type == elem_type_real)
		{
			REAL value = 0; fread(&value, sizeof(REAL), 1, KeytableDB);
			elem_value = new element(value);
		}
		else if (type == elem_type_char)
		{
			short length; fread(&length, sizeof(short), 1, KeytableDB);
			char* value = new char[length+1]; fgets(value, length+1, KeytableDB);
			elem_value = new element(value);
			delete(value);
		}
		else if (type == elem_type_vector)
		{
			Vector *value = new Vector(); fread(value, sizeof(Vector), 1, KeytableDB);
			elem_value = new element(value);
		}
		Keytable_Set(Keytable,index,elem_value);
		delete (index);
	}
	fclose(KeytableDB);
	return KeytableIndex;
}

static cell AMX_NATIVE_CALL Keytable_Save_ASCII(AMX *amx, cell *params)
{
	//params[1]: file
	int filename_length;
	char *inputfile = MF_GetAmxString(amx, params[1], 0, &filename_length);
	inputfile = MF_BuildPathname("%s", inputfile);
	FILE *KeytableDB = fopen(inputfile, "a+");
	if (!KeytableDB)
		return 0;

	char *outputfile = MF_GetAmxString(amx, params[2], 0, &filename_length);
	outputfile = MF_BuildPathname("%s", outputfile);
	FILE *ReadableDB = fopen(outputfile, "w");

	char *buffer = "\0";

	while(!feof(KeytableDB))
	{
		char* key = NULL; char type = 0; short key_len;
		fread(&key_len, sizeof(short), 1, KeytableDB);
		key = new char[key_len+1];
		fgets(key, key_len+1, KeytableDB);
		if (feof(KeytableDB) || ferror(KeytableDB))
			break;
		fread(&type, sizeof(char), 1, KeytableDB);

		sprintf(buffer, "Key %-32s Length %3d, Type %7s", key, key_len, elem_types[type]);
		if (type < elem_type_int || type > elem_type_vector)
		{
			MF_LogError(amx, AMX_ERR_FORMAT, "Error loading array database \"%s\" into readable format. Bad file.", inputfile);
			return 0;
		}
		else if (type == elem_type_int)
		{
			int value = 0; fread(&value, sizeof(int), 1, KeytableDB);
			fprintf(ReadableDB, "%s\t\t\t\tValue: %d\n", buffer, value);
		}
		else if (type == elem_type_real)
		{
			REAL value = 0; fread(&value, sizeof(REAL), 1, KeytableDB);
			fprintf(ReadableDB, "%s\t\t\t\tValue: %f\n", buffer, value);
		}
		else if (type == elem_type_char)
		{
			short length; fread(&length, sizeof(short), 1, KeytableDB);
			char* value = new char[length+1]; fgets(value, length+1, KeytableDB);
			fprintf(ReadableDB, "%s Length %3d\tValue: \"%s\"\n", buffer, length, value);
			delete value;
		}
		else if (type == elem_type_vector)
		{
			Vector *value = new Vector(); fread(value, sizeof(Vector), 1, KeytableDB);
			fprintf(ReadableDB, "%s\t\t\t\tValue: {%f,%f,%f}\n", buffer, (*value).x, (*value).y, (*value).z);
			delete value;
		}
	}
	fclose(KeytableDB);
	fclose(ReadableDB);
	return 1;
}

template <class Type> //This will support input char*, Vector*, int, and cell_real*.
void Keytable_Set(PPvoid_t Keytable, char* Index, Type value)
{
	PPvoid_t PValue;						// pointer to keytable element value
	PValue = JudySLIns(Keytable, Index, PJE0);
	*PValue = reinterpret_cast<void*>(value);
}

PPvoid_t Keytable_Get(AMX* amx, PPvoid_t Keytable, char *Index, int ignore_error = 0)
{
	PPvoid_t PValue = JudySLGet( *Keytable, Index, PJE0 );
	if (PValue == NULL && !ignore_error)
		MF_LogError(amx, AMX_ERR_NATIVE, "Keytable get on key \"%s\" is invalid", Index);
	return PValue;
}

static cell AMX_NATIVE_CALL Keytable_Create(AMX *amx, cell *params)
{
	return New_Keytable(params[1],params[2]);
}

static cell AMX_NATIVE_CALL Keytable_Delete(AMX *amx, cell *params)
{
	Delete_Keytable( params[1] );

	return 1;
}

static cell AMX_NATIVE_CALL Keytable_Clear(AMX *amx, cell *params)
{
	Clear_Keytable( params[1] );

	return 1;
}

static cell AMX_NATIVE_CALL Keytable_SetVector(AMX *amx,cell *params)
{
	PPvoid_t Keytable = Find_Keytable(params[1], params[4], amx);
	if (Keytable == NULL) return 0;

	cell *input_vec = MF_GetAmxAddr(amx, params[3]); 
	Vector *value = new Vector(
		amx_ctof(input_vec[0]), 
		amx_ctof(input_vec[1]), 
		amx_ctof(input_vec[2])
	);
	int strlen;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlen);

	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, 1);
	element *elem_value = NULL;
	if ( PValue == NULL )
		elem_value = new element(value);
	else
	{
		elem_value = reinterpret_cast<element*>(*PValue);
		(*elem_value).set_vec(value);
	}
	Keytable_Set(Keytable,Index,elem_value);
	return 1;
}

static cell AMX_NATIVE_CALL Keytable_GetVector(AMX *amx, cell *params)
{
	PPvoid_t Keytable = Find_Keytable(params[1], params[4], amx);
	if (Keytable == NULL) return 0;

	int strlen;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlen);
	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, params[4]);

	cell *vAmx = MF_GetAmxAddr(amx, params[3]);

	if( PValue == NULL ) {
		vAmx[0] = amx_ftoc(0);
		vAmx[1] = amx_ftoc(0);
		vAmx[2] = amx_ftoc(0);
		return 0;
	}
	element elem_value = *reinterpret_cast<element*>(*PValue);
	int error = 0;
	const Vector retr_vec = *elem_value.get_vec(error);
	if (error)
		elem_value.issue_type_error(amx, params[1], Index);
	vAmx[0] = amx_ftoc(retr_vec.x);
	vAmx[1] = amx_ftoc(retr_vec.y);
	vAmx[2] = amx_ftoc(retr_vec.z);
	return 1;
}

static cell AMX_NATIVE_CALL Keytable_SetString(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[4], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	//params[3]: value
	int iLen = 0;
	char *value = MF_GetAmxString(amx,params[3],1,&iLen);

	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, 1);
	element *elem_value = NULL;
	if ( PValue == NULL )
		elem_value = new element(value);
	else
	{
		elem_value = reinterpret_cast<element*>(*PValue);
		(*elem_value).set_str(value);
	}
	Keytable_Set(Keytable,Index,elem_value);

	return 1;
}

static cell AMX_NATIVE_CALL Keytable_GetString(AMX *amx,cell *params) 
{ 
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[5], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	
	Pvoid_t * PValue = Keytable_Get(amx, Keytable, Index, params[5]);

	//params[3] and params[4] are the return string and length respectively.
	

	if( PValue == NULL ) 
		return MF_SetAmxString(amx, params[3] , "dne", params[4] );

	element elem_value = *reinterpret_cast<element*>(*PValue);

	int error = 0;
	if (error)
		elem_value.issue_type_error(amx, params[1], Index);
	const char* str_out = elem_value.get_str(error);
	return MF_SetAmxString( amx , params[3] , str_out, params[4] );
}

static cell AMX_NATIVE_CALL Keytable_SetFloat(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[4], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//params[3]: value
	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, 1);
	element *elem_value = NULL;
	if ( PValue == NULL )
		elem_value = new element(amx_ctof(params[3]));
	else
	{
		elem_value = reinterpret_cast<element*>(*PValue);
		(*elem_value).set_flo(amx_ctof(params[3]));
	}
	Keytable_Set(Keytable,Index,elem_value);

	return 1;
}

static cell AMX_NATIVE_CALL Keytable_GetFloat(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[3], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, params[3]);

	if( PValue == NULL ) return amx_ftoc(0.0);

	element elem_value = *reinterpret_cast<element*>(*PValue);

	int error = 0;
	cell retr_float = amx_ftoc(elem_value.get_flo(error));
	if (error)
		elem_value.issue_type_error(amx, params[1], Index);
	return retr_float;
}


static cell AMX_NATIVE_CALL Keytable_SetInt(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[4], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	PPvoid_t PValue = Keytable_Get(amx, Keytable, Index, 1);
	element *elem_value = NULL;
	if ( PValue == NULL )
		elem_value = new element(params[3]);
	else
	{
		elem_value = reinterpret_cast<element*>(*PValue);
		(*elem_value).set_int(params[3]);
	}
	Keytable_Set(Keytable,Index,elem_value);

	return 1;
}

static cell AMX_NATIVE_CALL Keytable_GetInt(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[3], amx);
	if (Keytable == NULL) return 0;
	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	Pvoid_t * PValue = Keytable_Get(amx, Keytable, Index, params[3]);

	if( PValue == NULL ) return 0;

	element elem_value = *reinterpret_cast<element*>(*PValue);

	int error = 0;
	cell retr_int = elem_value.get_int(error);
	if (error)
		elem_value.issue_type_error(amx, params[1], Index);
	return retr_int;
}

static cell AMX_NATIVE_CALL Keytable_Memory(AMX *amx,cell *params)
{
	Pvoid_t * Keytable = Find_Keytable(params[1],params[2],amx);
	if (Keytable == NULL) return 0;
	
	return JudyLMemUsed(*Keytable);
}

static cell AMX_NATIVE_CALL Keytable_Remove(AMX *amx,cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], 0, amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//Have to delete the element
	PPvoid_t PValue = JudySLGet(*Keytable, Index, PJE0);
	if (PValue == NULL) return 1;
	element elem_value = *reinterpret_cast<element*>(*PValue);
	elem_value.delete_element();

	JudySLDel(Keytable, Index, PJE0 );
	return 1;
}

static cell AMX_NATIVE_CALL Keytable_Next(AMX *amx,cell *params)  
{  
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[5], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//params[3], params[4]: return key and length
	
	PPvoid_t pointer;  
	pointer = JudySLNext(*Keytable, Index, PJE0);  

	if (pointer == NULL) {
		MF_SetAmxString(amx, params[3], "dne", 0);
		return 0;
	}
	MF_SetAmxString(amx, params[3], Index, params[4]);
	return 1;
} 

static cell AMX_NATIVE_CALL Keytable_Prev(AMX *amx,cell *params)  
{  
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[5], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//params[3], params[4]: return key and length
	
	PPvoid_t pointer;
	pointer = JudySLPrev(*Keytable, Index, PJE0);  

	if (pointer == NULL) {
		MF_SetAmxString(amx, params[3], "dne", 0);
		return 0;
	}
	MF_SetAmxString(amx, params[3], Index, params[4]);
	return 1;
} 


static cell AMX_NATIVE_CALL Keytable_First(AMX *amx,cell *params)  
{  
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[5], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//params[3], params[4]: return key and length
	
	PPvoid_t pointer;
	pointer = JudySLFirst(*Keytable, Index, PJE0);  

	if (pointer == NULL) {
		MF_SetAmxString(amx, params[3], "dne", 0);
		return 0;
	}
	MF_SetAmxString(amx, params[3], Index, params[4]);
	return 1;
} 

static cell AMX_NATIVE_CALL Keytable_Last(AMX *amx,cell *params)  
{  
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[5], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);
	//params[3], params[4]: return key and length
	
	PPvoid_t pointer;
	pointer = JudySLLast(*Keytable, Index, PJE0);  

	if (pointer == NULL) {
		MF_SetAmxString(amx, params[3], "dne", 0);
		return 0;
	}
	MF_SetAmxString(amx, params[3], Index, params[4]);
	return 1;
}

static cell AMX_NATIVE_CALL Key_IsEmpty(AMX *amx, cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[3], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	PPvoid_t pointer = JudySLGet(*Keytable, Index, PJE0);
	
	return (pointer == NULL) ? 1 : 0;
}

static cell AMX_NATIVE_CALL Key_IsFilled(AMX *amx, cell *params)
{
	//params[1]: keytable
	PPvoid_t Keytable = Find_Keytable(params[1], params[3], amx);
	if (Keytable == NULL) return 0;

	//params[2]: key
	int strlength;
	char *Index = MF_GetAmxString(amx, params[2], 0, &strlength);

	PPvoid_t pointer = JudySLGet(*Keytable, Index, PJE0);

	return (pointer != NULL) ? 1 : 0;
}

AMX_NATIVE_INFO keytable_exports[] = {
  { "keytable_set_string",	Keytable_SetString	},
  { "keytable_get_string",	Keytable_GetString	},

  { "keytable_set_vector",	Keytable_SetVector	},
  { "keytable_get_vector",	Keytable_GetVector	},

  { "keytable_set_int",		Keytable_SetInt		},
  { "keytable_get_int",		Keytable_GetInt		},

  { "keytable_set_float",	Keytable_SetFloat	},
  { "keytable_get_float",	Keytable_GetFloat	},

  { "keytable_isempty",		Key_IsEmpty			},
  { "keytable_isfilled",	Key_IsFilled		},

  { "keytable_memory",		Keytable_Memory		},

  { "keytable_remove",		Keytable_Remove		},

  { "keytable_create",		Keytable_Create		},
  { "keytable_delete",		Keytable_Delete		},
  { "keytable_clear",		Keytable_Clear		},

  { "keytable_next",		Keytable_Next		}, 
  { "keytable_prev",		Keytable_Prev		}, 
  { "keytable_first",		Keytable_First		}, 
  { "keytable_last",		Keytable_Last		},

  { "keytable_save",		Keytable_Save		},
  { "keytable_load",		Keytable_Load		},
  
  { "keytable_save_ascii",	Keytable_Save_ASCII	},

  { NULL, NULL }
};

#endif