sourcemod-central: extensions/structs/StructHandle.cpp@bee90c8ef6c3

     1 /**

     2 * vim: set ts=4 :

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

     4 * SourceMod Sample Extension

     5 * Copyright (C) 2004-2008 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 "StructHandle.h"

    33 #include "extension.h"

    35 bool StructHandle::GetInt( const char *member, int *value )

    36 {

    37 	int offset;

    39 	if (!info->getOffset(member, &offset))

    40 	{

    41 		return false;

    42 	}

    44 	MemberType type;

    46 	if (!info->getType(member, &type))

    47 	{

    48 		return false;

    49 	}

    51 	switch (type)

    52 	{

    53 		case Member_Int8:

    54 		{

    55 			*value = *(uint8 *)((unsigned char *)data + offset);

    56 			break;

    57 		}

    59 		case Member_Int16:

    60 		{

    61 			*value = *(uint16 *)((unsigned char *)data + offset);

    62 			break;

    63 		}

    65 		case Member_Int32:

    66 		{

    67 			*value = *(uint32 *)((unsigned char *)data + offset);

    68 			break;

    69 		}

    71 		case Member_Int8Pointer:

    72 		{

    73 			*value = **(uint8 **)((unsigned char *)data + offset);

    74 			break;

    75 		}

    77 		case Member_Int16Pointer:

    78 		{

    79 			*value = **(uint16 **)((unsigned char *)data + offset);

    80 			break;

    81 		}

    83 		case Member_Int32Pointer:

    84 		{

    85 			*value = **(uint32 **)((unsigned char *)data + offset);

    86 			break;

    87 		}

    89 		default:

    90 		{

    91 			return false;

    92 		}

    93 	}

    95 	return true;

    96 }

    98 bool StructHandle::GetFloat( const char *member, float *value )

    99 {

   100 	int offset;

   102 	if (!info->getOffset(member, &offset))

   103 	{

   104 		return false;

   105 	}

   107 	MemberType type;

   109 	if (!info->getType(member, &type))

   110 	{

   111 		return false;

   112 	}

   114 	switch (type)

   115 	{

   116 		case Member_Float:

   117 		{

   118 			*value = *(float *)((unsigned char *)data + offset);

   119 			break;

   120 		}

   122 		case Member_FloatPointer:

   123 		{

   124 			*value = **(float **)((unsigned char *)data + offset);

   125 			break;

   126 		}

   128 		default:

   129 		{

   130 			return false;

   131 		}

   132 	}

   134 	return true;

   135 }

   137 bool StructHandle::SetInt( const char *member, int value )

   138 {

   139 	int offset;

   141 	if (!info->getOffset(member, &offset))

   142 	{

   143 		return false;

   144 	}

   146 	MemberType type;

   148 	if (!info->getType(member, &type))

   149 	{

   150 		return false;

   151 	}

   153 	switch (type)

   154 	{

   155 		case Member_Int8:

   156 		{

   157 			*(uint8 *)((unsigned char *)data + offset) = value;

   158 			break;

   159 		}

   161 		case Member_Int16:

   162 		{

   163 			*(uint16 *)((unsigned char *)data + offset) = value;

   164 			break;

   165 		}

   167 		case Member_Int32:

   168 		{

   169 			*(uint32 *)((unsigned char *)data + offset) = value;

   170 			break;

   171 		}

   173 		case Member_Int8Pointer:

   174 		{

   175 			**(uint8 **)((unsigned char *)data + offset) = value;

   176 			break;

   177 		}

   179 		case Member_Int16Pointer:

   180 		{

   181 			**(uint16 **)((unsigned char *)data + offset) = value;

   182 			break;

   183 		}

   185 		case Member_Int32Pointer:

   186 		{

   187 			**(uint32 **)((unsigned char *)data + offset) = value;

   188 			break;

   189 		}

   191 		default:

   192 		{

   193 			return false;

   194 		}

   195 	}

   197 	return true;

   198 }

   200 bool StructHandle::SetFloat( const char *member, float value )

   201 {

   202 	int offset;

   204 	if (!info->getOffset(member, &offset))

   205 	{

   206 		return false;

   207 	}

   209 	MemberType type;

   211 	if (!info->getType(member, &type))

   212 	{

   213 		return false;

   214 	}

   216 	switch (type)

   217 	{

   218 		case Member_Float:

   219 		{

   220 			*(float *)((unsigned char *)data + offset) = value;

   221 			break;

   222 		}

   224 		case Member_FloatPointer:

   225 		{

   226 			**(float **)((unsigned char *)data + offset) = value;

   227 			break;

   228 		}

   230 		default:

   231 		{

   232 			return false;

   233 		}

   234 	}

   236 	return true;

   237 }

   239 bool StructHandle::IsPointerNull( const char *member, bool *result )

   240 {

   241 	int offset;

   243 	if (!info->getOffset(member, &offset))

   244 	{

   245 		return false;

   246 	}

   248 	MemberType type;

   250 	if (!info->getType(member, &type))

   251 	{

   252 		return false;

   253 	}

   255 	switch (type)

   256 	{

   257 		case Member_Int8Pointer:

   258 		case Member_Int16Pointer:

   259 		case Member_Int32Pointer:

   260 		case Member_FloatPointer:

   261 		case Member_CharPointer:

   262 		case Member_VectorPointer:

   263 		case Member_EHandlePointer:

   264 		{

   265 			*result = *((unsigned char **)data + offset) == NULL;

   266 			break;

   267 		}

   269 		default:

   270 		{

   271 			return false;

   272 		}

   273 	}

   275 	return true;

   276 }

   278 bool StructHandle::setPointerNull( const char *member )

   279 {

   280 	int offset;

   282 	if (!info->getOffset(member, &offset))

   283 	{

   284 		return false;

   285 	}

   287 	MemberType type;

   289 	if (!info->getType(member, &type))

   290 	{

   291 		return false;

   292 	}

   294 	switch (type)

   295 	{

   296 		case Member_Int8Pointer:

   297 		case Member_Int16Pointer:

   298 		case Member_Int32Pointer:

   299 		case Member_FloatPointer:

   300 		case Member_CharPointer:

   301 		case Member_VectorPointer:

   302 		case Member_EHandlePointer:

   303 		{

   304 			*((unsigned char **)data + offset) = NULL;

   305 			break;

   306 		}

   308 		default:

   309 		{

   310 			return false;

   311 		}

   312 	}

   314 	return true;

   315 }

   317 bool StructHandle::GetVector( const char *member, Vector *vec )

   318 {

   319 	int offset;

   321 	if (!info->getOffset(member, &offset))

   322 	{

   323 		return false;

   324 	}

   326 	MemberType type;

   328 	if (!info->getType(member, &type))

   329 	{

   330 		return false;

   331 	}

   333 	switch (type)

   334 	{

   335 		case Member_Vector:

   336 		{

   337 			*vec = *(Vector *)((unsigned char *)data + offset);

   338 			break;

   339 		}

   341 		case Member_VectorPointer:

   342 		{

   343 			*vec = **(Vector **)((unsigned char *)data + offset);

   344 			break;

   345 		}

   347 		default:

   348 		{

   349 			return false;

   350 		}

   351 	}

   353 	return true;

   354 }

   356 bool StructHandle::SetVector( const char *member, Vector vec )

   357 {

   358 	int offset;

   360 	if (!info->getOffset(member, &offset))

   361 	{

   362 		return false;

   363 	}

   365 	MemberType type;

   367 	if (!info->getType(member, &type))

   368 	{

   369 		return false;

   370 	}

   372 	switch (type)

   373 	{

   374 		case Member_Vector:

   375 		{

   376 			*(Vector *)((unsigned char *)data + offset) = vec;

   377 			break;

   378 		}

   380 		case Member_VectorPointer:

   381 		{

   382 			**(Vector **)((unsigned char *)data + offset) = vec;

   383 			break;

   384 		}

   386 		default:

   387 		{

   388 			return false;

   389 		}

   390 	}

   392 	return true;

   393 }

   395 bool StructHandle::GetString( const char *member, char **string )

   396 {

   397 	int offset;

   399 	if (!info->getOffset(member, &offset))

   400 	{

   401 		return false;

   402 	}

   404 	MemberType type;

   406 	if (!info->getType(member, &type))

   407 	{

   408 		return false;

   409 	}

   411 	switch (type)

   412 	{

   413 		case Member_Char:

   414 		{

   415 			*string = (char *)((unsigned char *)data + offset);

   416 			break;

   417 		}

   419 		case Member_CharPointer:

   420 		{

   421 			*string = *(char **)((unsigned char *)data + offset);

   422 			break;

   423 		}

   425 		default:

   426 		{

   427 			return false;

   428 		}

   429 	}

   431 	return true;

   432 }

   434 bool StructHandle::SetString( const char *member, char *string )

   435 {

   436 	int offset;

   438 	if (!info->getOffset(member, &offset))

   439 	{

   440 		return false;

   441 	}

   443 	MemberType type;

   445 	if (!info->getType(member, &type))

   446 	{

   447 		return false;

   448 	}

   450 	switch (type)

   451 	{

   452 		case Member_Char:

   453 		{

   454 			int size;

   455 			info->getSize(member, &size);

   456 			char *location = (char *)data + offset;

   457 			UTIL_Format(location, size, "%s", string);

   458 			break;

   459 		}

   461 		case Member_CharPointer:

   462 		{

   463 			int size;

   464 			info->getSize(member, &size);

   465 			char *location = *(char **)((unsigned char *)data + offset);

   466 			UTIL_Format(location, size, "%s", string);

   467 			break;

   468 		}

   470 		default:

   471 		{

   472 			return false;

   473 		}

   474 	}

   476 	return true;

   477 }

   479 bool StructHandle::GetEHandle( const char *member, CBaseHandle **handle )

   480 {

   481 	int offset;

   483 	if (!info->getOffset(member, &offset))

   484 	{

   485 		return false;

   486 	}

   488 	MemberType type;

   490 	if (!info->getType(member, &type))

   491 	{

   492 		return false;

   493 	}

   495 	switch (type)

   496 	{

   497 		case Member_EHandle:

   498 		{

   499 			*handle = (CBaseHandle *)((unsigned char *)data + offset);

   500 			break;

   501 		}

   503 		case Member_EHandlePointer:

   504 		{

   505 			*handle = *(CBaseHandle **)((unsigned char *)data + offset);

   506 			break;

   507 		}

   509 		default:

   510 		{

   511 			return false;

   512 		}

   513 	}

   515 	return true;

   516 }

   518 bool StructHandle::SetEHandle( const char *member, CBaseHandle *handle )

   519 {

   520 	int offset;

   522 	if (!info->getOffset(member, &offset))

   523 	{

   524 		return false;

   525 	}

   527 	MemberType type;

   529 	if (!info->getType(member, &type))

   530 	{

   531 		return false;

   532 	}

   534 	switch (type)

   535 	{

   536 		case Member_Float:

   537 		{

   538 			*(CBaseHandle *)((unsigned char *)data + offset) = *handle;

   539 			break;

   540 		}

   542 		case Member_FloatPointer:

   543 		{

   544 			**(CBaseHandle **)((unsigned char *)data + offset) = *handle;

   545 			break;

   546 		}

   548 		default:

   549 		{

   550 			return false;

   551 		}

   552 	}

   554 	return true;

   555 }

author	Asher Baker <asherkin@gmail.com>
	Thu Apr 26 16:58:18 2012 +0100 (2012-04-26)
changeset 3488	bee90c8ef6c3
parent 2224	676c3b826f13
permissions	-rw-r--r--