[Collection/Sammelthread] Code-Snippets / Code-Schnipsel

        public string SizeString(long bytes)
        {
            string[] format = {"Bytes", "KB", "MB", "GB", "TB", "PB", "EB"};
            int i = 0;
            for (i = 0; i < format.Length && bytes >= 1024; i++)
                bytes = (100 * bytes / 1024) / 100;
            return string.Format("{0:F2} " + format[i], bytes);
        }

template <typename F>
class EventHandler;

template<typename F, typename ...Args>
class EventHandler<F(Args...)>
{
	typedef F (*Func)(Args...);
	std::vector<Func> functions;
public:
	void connect(Func f)
	{
		if (std::find(functions.begin(), functions.end(), f) == functions.end())
			functions.push_back(f);
	}
    
	void disconnect(Func f)
	{
		auto it = std::find(functions.begin(), functions.end(), f);
		if (it != functions.end())
		{
			functions.erase(it);
		}
	}
    
	EventHandler() { };
	EventHandler(const EventHandler& listener) : functions(listener.functions) { };
    
	F operator()(Args... args)
	{
		auto maxIndex = functions.size() - 1;
		if (functions.size() > 1)
		{
			for (size_t i = 0; i != maxIndex; ++i)
			{
				(functions[i])(args...);
			}
		}
		return functions[maxIndex](args...);
	}
    
	void clear()
	{
		functions.clear();
	}
    
	bool empty() const
	{
		return functions.empty();
	}
    
	auto size() const -> decltype(functions.size())
	{
		return functions.size();
	}
    
	auto begin() const -> decltype(functions.begin())
 	{
		return functions.begin();
	}
    
	auto end() const -> decltype(functions.end())
	{
		return functions.begin();
	}
    
	EventHandler operator+(Func f)
	{
		EventHandler copy(*this);
		copy += f;
		return copy;
	}
    
	EventHandler& operator+=(Func f)
	{
		connect(f);
		return *this;
	}
    
	EventHandler operator-(Func f)
	{
		EventHandler copy(*this);
		copy -= f;
		return copy;
	}
    
	EventHandler& operator-=(Func f)
	{
		disconnect(f);
		return *this;
	}
};

    
   auto lambdaEventHandler = [](int i, int j) -> int { return 2 * j + i; };
    
    EventHandler<int(int, int)> handler;
    handler += someFunctionAddress;
    handler += lambdaEventHandler;
    
    std::cout << handler(3, 4) << std::endl; // output = 11

   
Button b("buttonTitle");
b += [](const Element& element, EventInformation information) { std::cout << "Click!" << std::endl; };

// in our message loop
WORD reason = 0x1337;
b.ButtonEvent(reason); // calls eventHandler(*this, EventInformation());

        public static String[] GetSubstring(string strBegin, string strEnd, string strSource, bool includeBegin, bool includeEnd)
        {
            string[] result = { "", "" };
            int iIndexOfBegin = strSource.IndexOf(strBegin);
            if (iIndexOfBegin != -1)
            {
                if (includeBegin)
                    iIndexOfBegin -= strBegin.Length;
                strSource = strSource.Substring(iIndexOfBegin + strBegin.Length);
                int iEnd = strSource.IndexOf(strEnd);
                if (iEnd != -1)
                {
                    if (includeEnd)
                        iEnd += strEnd.Length;
                    result[0] = strSource.Substring(0, iEnd);
                    if (iEnd + strEnd.Length < strSource.Length)
                        result[1] = strSource.Substring(iEnd + strEnd.Length);
                }
            }
            else
                result[1] = strSource;
            return result;
        }

BOOL IsAdministrator(VOID)
{
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    PSID AdministratorsGroup;

    if( !AllocateAndInitializeSid(&NtAuthority,2,SECURITY_BUILTIN_DOMAIN_RID,
        DOMAIN_ALIAS_RID_ADMINS,0, 0, 0, 0, 0, 0,&AdministratorsGroup))
    {
        return FALSE;
    }

    BOOL IsInAdminGroup = FALSE;

    if(!CheckTokenMembership(NULL,AdministratorsGroup,&IsInAdminGroup))
    {
       IsInAdminGroup = FALSE;
    }

    FreeSid(AdministratorsGroup);
    return IsInAdminGroup;
}

if(IsAdministrator()==FALSE)
{
	MessageBoxA(0, "Please start it as admin !", "Error", MB_ICONERROR);
	return 1;
}

<?php

	if (!isset($_REQUEST['user']) || !isset($_REQUEST['password']))
	{
		echo "error";
		return;
	}

	// init
	$user = $_REQUEST['user'];
	$password = $_REQUEST['password'];
	$sqlConnection = new mysqli("localhost", "root", "password", "database");
	
	// prepare + execute statement
	$statement = $sqlConnection->prepare("SELECT * FROM table WHERE username = ? AND password = ? LIMIT 1");
	$statement->bind_param('ss', $user, $password);
	$statement->execute();
	
	// get the result
	$result = $statement->get_result();
	$row = $result->fetch_assoc();
	$output = $row['column'];
	
	// clean up
	$statement->close();
	$sqlConnection->close();

	echo $output;
?>

void sendKey(int vk, BOOL bExtended) {

	KEYBDINPUT  kb = {0};
	INPUT       Input = {0};
	int scan = MapVirtualKey(vk, 0);

	/* Generate a "key down" */
	if (bExtended) { kb.dwFlags  = KEYEVENTF_EXTENDEDKEY; }
	kb.wVk  = vk;
	Input.type  = INPUT_KEYBOARD;
	Input.ki  = kb;
	Input.ki.wScan = scan;
	SendInput(1, &Input, sizeof(Input));

	/* Generate a "key up" */
	ZeroMemory(&kb, sizeof(KEYBDINPUT));
	ZeroMemory(&Input, sizeof(INPUT));
	kb.dwFlags  =  KEYEVENTF_KEYUP;
	if (bExtended) { kb.dwFlags |= KEYEVENTF_EXTENDEDKEY; }
	kb.wVk = vk;
	Input.type = INPUT_KEYBOARD;
	Input.ki = kb;
	Input.ki.wScan = scan;
	SendInput(1, &Input, sizeof(Input));

	return;
}

array_walk($_GET, create_function('&$value', 'return $value=htmlspecialchars(mysql_escape_string($value));'));
array_walk($_POST, create_function('&$value', 'return $value=htmlspecialchars(mysql_escape_string($value));'));

FindData proc input:DWORD, search:DWORD, len:DWORD, s_len:DWORD
	LOCAL cnt:DWORD, result:DWORD, i:DWORD, j:DWORD
	mov i, 0
	mov cnt, 0
	@main_loop:
		pushad
		mov cnt, 0
		mov eax, dword ptr ds:[input]
		add eax, i
		movzx edx, byte ptr ds:[eax]
		mov eax, dword ptr ds:[search]
		add eax, cnt
		movzx ecx, byte ptr ds:[eax]
		cmp edx, ecx
		jne @Next
		mov j, 0
		@second_loop:
			mov eax, dword ptr ds:[input]
			add eax, i
			add eax, j
			movzx edx, byte ptr ds:[eax]
			mov eax, dword ptr ds:[search]
			add eax, cnt
			movzx ecx, byte ptr ds:[eax]
			cmp edx, ecx
			jne @Next
			mov edx, i
			mov result, edx
			inc cnt
			mov edx, s_len
			inc j
			cmp j, edx
			jl @second_loop
			jmp @End
		@Next:
		popad
		mov edx, len
		inc i
		cmp i, edx
		jl @main_loop
	@End:
	mov eax, result
	ret

FindData endp

//1 Parameter: Byte Array in welchem gesucht wird
//2 Parameter: Byte Array welches gesucht werden soll
//3 Parameter: Länge des Parameter 1
//4 Parameter: Länge des Parameter 2
invoke FindData, addr szTest, addr szABC, 11, 3

	function REQUEST($attr, $mysqlEscape = false) {
		if(isset($_REQUEST[$attr]))
			return SpecialChars($_REQUEST[$attr]);
	}
	
	function GET($attr, $mysqlEscape = false) {
		if(isset($_GET[$attr]))
			return SpecialChars($_GET[$attr], $mysqlEscape);
	}
	
	function POST($attr, $mysqlEscape = false) {
		if(isset($_POST[$attr]))
			return SpecialChars($_POST[$attr], $mysqlEscape);
	}
	
	function SpecialChars($str, $mysqlEscape = false) {
		$ret = htmlspecialchars($str);
		return ($mysqlEscape ? mysql_real_escape_string($ret) : $ret);
	}

$var = null;
if(isset($_GET['param']))
  $var = $_GET['param'];

$var = GET('param', true); // true für ein mysql_escape_string

	class TimeDiff {
		private $Diff;
		public function __construct() {
			$this->Reset();
		}
		public function Reset() {
			$this->Diff = microtime(true);
		}
		public function Get() {
			return round(microtime(true) - $this->Diff, 4);
		}
	}

	$diffTotal = new TimeDiff();
	
	$diff = new TimeDiff();
	$str = '';
	for($i = 0; $i < 1 * 1000 * 1000; $i++)
		$str .= 'test';
	echo 'Test took ' . $diff->Get() . ' seconds<br>';
	
	$diff->Reset();
	$str = '';
	for($i = 0; $i < 10 * 1000 * 1000; $i++)
		$str .= 'test';
	echo 'Another took ' . $diff->Get() . ' seconds<br>';
	
	echo 'Together they took ' . $diffTotal->Get() . ' seconds<br>';

Test took 0.1256 seconds
Another took 2.8481 seconds
Together they took 2.9738 seconds