@amxts/core 0.1.0

package/amxmodx/base/include/sockets.inc

@@ -0,0 +1,183 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// Socket Functions
+//
+
+#if defined _socket_included
+	#endinput
+#endif
+#define _socket_included
+
+#pragma reqlib sockets
+#if !defined AMXMODX_NOAUTOLOAD
+	#pragma loadlib sockets
+#endif
+
+/**
+ * Socket connection type (TCP/UDP)
+ */
+#define SOCKET_TCP 1
+#define SOCKET_UDP 2
+
+/**
+ * Socket flags
+ */
+#define SOCK_NON_BLOCKING (1 << 0)    /* Set the socket a nonblocking */
+#define SOCK_LIBC_ERRORS  (1 << 1)    /* Enable libc error reporting */
+
+/**
+ * Error reporting
+ */
+#define SOCK_ERROR_OK               0 /* No error */
+#define SOCK_ERROR_CREATE_SOCKET    1 /* Couldn't create a socket */
+#define SOCK_ERROR_SERVER_UNKNOWN   2 /* Server unknown */
+#define SOCK_ERROR_WHILE_CONNECTING 3 /* Error while connecting */
+
+/**
+ * Connects to the given node and service via TCP/UDP.
+ *
+ * @note There's 2 types of error reporting on this function that you can use.
+ * @note Default error codes:
+ *       0 - No error
+ *       1 - Error while creating socket
+ *       2 - Couldn't resolve hostname
+ *       3 - Couldn't connect
+ * @note New, more expressive libc error codes:
+ *       https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html
+ *       https://github.com/torvalds/linux/blob/master/include/uapi/asm-generic/errno.h
+ *       https://msdn.microsoft.com/en-us/library/ms740668.aspx
+ *
+ * @note The currently available bit flags are:
+ *       - SOCK_NON_BLOCKING : if set, the socket will be on nonblocking mode
+ *       - SOCK_LIBC_ERRORS : if set, the new libc errors will be seen on _error
+ *
+ * @note If no flags are set, the behaviour of the function will not be modified.
+ *
+ * @note Multiple flags may be set at the same time using the | operator. 
+ *       For example, SOCK_NON_BLOCKING|SOCK_LIBC_ERRORS will create a nonblocking socket with libc error codes.
+ *
+ * @note If you're creating a new nonblocking socket, _hostname should be numeric to avoid calling the 
+ *       name resolution server and potentially blocking the call.
+ *
+ * @note If the socket is a nonblocking one, the returned socket descriptor may be still connecting and 
+ *       further checks should be done with socket_is_writable() before trying to send data.
+ *
+ * @param _hostname    Node to connect to
+ * @param _port        Service to connect to
+ * @param _protocol    Connect via SOCKET_TCP or SOCKET_UDP
+ * @param _error       Set an error code here if anything goes wrong
+ * @param _flags       Optional bit flags that change the behaviour of the function
+ *
+ * @return             A socket descriptor (a positive integer) on success
+ *                     -1 on failure
+*/
+native socket_open(const _hostname[], _port, _protocol = SOCKET_TCP, &_error, _flags = 0);
+
+/**
+ * Closes a socket.
+ *
+ * @param _socket    Socket descriptor
+ *
+ * @return           1 on success
+ *                   0 on failure
+ */
+native socket_close(_socket);
+
+/**
+ * Receives data.
+ *
+ * @note The amount of bytes than you end up receiving can be less than the one you expected.
+ *
+ * @note This function will completely block the server until some data arrives
+ *       to the given socket. Use this only if you are sure there is some data
+ *       to be retrieved. You can do that by polling with socket_is_readable().
+ *
+ * @param _socket    Socket descriptor
+ * @param _data      Array to save the data
+ * @param _length    Length of the array
+ *
+ * @return           Amount of bytes received
+ *                   0 if the peer closed the connection
+ *                   -1 on failure
+ */
+native socket_recv(_socket, _data[], _length);
+
+/**
+ * Sends data.
+ *
+ * @note The amount of bytes that end up being sent may be lower than the total length of the array,
+ *       check the return value and send the rest if needed.
+ *
+ * @param _socket    Socket descriptor
+ * @param _data      Array with the data to send
+ * @param _length    Length of the array
+ *
+ * @return           Amount of bytes sent
+ *                   -1 on failure
+ */
+native socket_send(_socket, const _data[], _length);
+
+/**
+ * Sends data that can contain null bytes.
+ *
+ * @note The amount of bytes that end up being sent may be lower than the total length of the array,
+ *       check the return value and send the rest if needed.
+ *
+ * @note strlen(_data) will return the wrong length if the array contains null bytes.
+ *
+ * @param _socket    Socket descriptor
+ * @param _data      Array with the data to send
+ * @param _length    Length of the array
+ *
+ * @return           Amount of bytes sent
+ *                   -1 on failure
+ */
+native socket_send2(_socket, const _data[], _length);
+
+/**
+ * Backwards compatible function.
+ *
+ * @deprecated Renamed to socket_is_readable()
+ */
+#pragma deprecated Use socket_is_readable() instead
+native socket_change(_socket, _timeout = 100000);
+
+/**
+ * Checks if a socket is marked as readable.
+ *
+ * @note You can use this function to make sure there's something on the socket and avoid a blocking call.
+ * @note Set _timeout to 0 avoid blocking the call.
+ * @note A socket will become readable if there's any data or an EOF.
+ *
+ * @param _socket    Socket descriptor
+ * @param _timeout   Amount of time to block the call waiting for the socket to be marked as readable or
+ *                   for the timeout to expire, in µSeconds (1 sec = 1000000 µsec)
+ *
+ * @return           1 if the socket is marked as readable
+ *                   0 otherwise
+ */
+native socket_is_readable(_socket, _timeout = 100000);
+
+/**
+ * Checks if a socket is marked as writable.
+ *
+ * @note Use this function to check if a nonblocking socket is ready to be used.
+ * @note Set _timeout to 0 avoid blocking the call.
+ * @note An UDP socket is always writable.
+ *
+ * @param _socket    Socket descriptor
+ * @param _timeout   Amount of time to block the call waiting for the socket to be marked as writable or
+ *                   for the timeout to expire, in µSeconds (1 sec = 1000000 µsec)
+ *
+ * @return           1 if the socket is marked as writable
+ *                   0 otherwise
+ */
+native socket_is_writable(_socket, _timeout = 100000);

package/amxmodx/base/include/sorting.inc

@@ -0,0 +1,107 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// Sorting Functions
+//
+
+//
+// All sort functions are based off the qsort() function from the
+//  C standard library, which uses the Quick Sort algorithm.
+// For more info, see: http://linux.wku.edu/~lamonml/algor/sort/sort.html
+//
+
+#if defined _sorting_included
+  #endinput
+#endif
+#define _sorting_included
+
+/**
+ * Contains sorting orders.
+ */
+enum SortMethod
+{
+	Sort_Ascending = 0,
+	Sort_Descending,
+	Sort_Random,
+};
+
+/**
+ * Data types for ADT Array Sorts
+ */
+enum SortType
+{
+	Sort_Integer = 0,
+	Sort_Float,
+ 	Sort_String,
+};
+/**
+ * Basic sorting functions below.
+ */
+
+native SortIntegers(array[], array_size, SortMethod:order = Sort_Ascending);
+
+native SortFloats(Float:array[], array_size, SortMethod:order = Sort_Ascending);
+
+native SortStrings(array[][], num_strings, SortMethod:order = Sort_Ascending);
+
+/**
+ * Custom sorting functions below.
+ */
+
+/** 
+ * Sorts a custom 1D array.  You must pass in a comparison function.
+ * The sorting algorithm then uses your comparison function to sort the data.
+ * The function is called in the following manner:
+ * 
+ * public MySortFunc(elem1, elem2, const array[], const data[], data_size)
+ *
+ *  elem1, elem2	- Current element pair being compared
+ *  array[]			- Array in its current mid-sorted state.
+ *  data[]			- Extra data array you passed to the sort func.
+ *  data_size		- Size of extra data you passed to the sort func.
+ *
+ * Your function should return:
+ *  -1 if elem1 should go before elem2
+ *   0 if elem1 and elem2 are equal
+ *   1 if elem1 should go after elem2
+ * Note that the parameters after elem2 are all optional and you do not need to specify them.
+ */
+native SortCustom1D(array[], array_size, const comparefunc[], data[]="", data_size=0);
+
+
+/** 
+ * Sorts a custom 2D array.
+ * The sorting algorithm then uses your comparison function to sort the data.
+ * The function is called in the following manner:
+ *
+ * public MySortFunc(const elem1[], const elem2[], const array[], data[], data_size)
+ *
+ *  elem1[], elem2[] - Current element array pairs being compared
+ *  array[][]		 - Array in its currently being sorted state.
+ *  data[]			 - Extra data array you passed to the sort func.
+ *  data_size		 - Size of extra data you passed to the sort func.
+ *
+ * Your function should return:
+ *  -1 if elem1[] should go before elem2[]
+ *   0 if elem1[] and elem2 are equal[]
+ *   1 if elem1[] should go after elem2[]
+ * Note that the parameters after elem2[] are all optional and you do not need to specify them.
+ */
+native SortCustom2D(array[][], array_size, const comparefunc[], data[]="", data_size=0);
+
+/**
+ * Sort an ADT Array. Specify the type as Integer, Float, or String.
+ *
+ * @param array			Array Handle to sort
+ * @param order			Sort order to use, same as other sorts.
+ * @param type			Data type stored in the ADT Array
+ * @noreturn
+ */
+native SortADTArray(Array:array, SortMethod:order, SortType:type);