Guilherme Lampert glampert

## in_place_function.hpp
#pragma once

// ============================================================================
// About:
//  std::function-like functor that has an inline buffer to store the
//  callable object. It is guaranteed to never allocate. If the callable
//  is too big, a static_assert is triggered. The size of the functor is
//  defined as a template argument, so it can be of any size. It also doesn't
//  use C++ exceptions.
//

## lockless_hash_table.cpp
// License:
//  Public Domain. Feel free to copy, distribute, and modify this file as you see fit.

#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstdio>

#include <array>
#include <atomic>

## tiny_allocator.cpp
//
// Simple allocator for small memory blocks (from 1 to 255 bytes).
// It keeps freelists of small blocks, built on top of 8K pages.
// The allocator only grows - empty pages are never freed back
// to the system.
//
// This allocator could easily be made lockless with atomic freelists.
//

#include <cstdint>

## mini_heap_allocator.cpp
//
// General purpose minimal heap allocator.
//
// Keeps a freelist of chunks of arbitrary size. First round of allocations
// will use the whole heap block before it starts going into the freelist.
// Freeing just pushes the block back into the freelist and is constant time.
// Allocating might search the freelist if the whole heap was already allocated
// once.
//
// To reduce fragmentation we could merge free nodes either on free or allocate.

## asan_guarded_allocator.cpp

// ----------------------------------------------------------------------------
// c++ -std=c++11 -Wall -Wextra -Wshadow -Wunused -pedantic -fsanitize=address -fno-omit-frame-pointer asan_guarded_allocator.cpp

#include <cassert>
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <unordered_map>

## cplusrust_option_result.cpp
// Mostly complete and usable C++ version of Rust's Option<T> and Result<T,E> using only standard C++14, for fun.
// This code is in the public domain.

///////////////////////////////////////////////////////////////////////////////
// Option.hpp
///////////////////////////////////////////////////////////////////////////////
#pragma once

// ----------------------------------------------------------------------------
// Includes

## fast_itoa.cpp
#include <cassert>
#include <cstdint>
#include <cstdarg>
#include <cstdio>
#include <cmath>

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <intrin.h>

## Memset.cpp
#include <cstdio>
#include <cstdint>
#include <cassert>
#include <xmmintrin.h>

///////////////////////////////////////////////////////////////////////////////

namespace detail
{
	#pragma once

	// ============================================================================
	// About:
	// std::function-like functor that has an inline buffer to store the
	// callable object. It is guaranteed to never allocate. If the callable
	// is too big, a static_assert is triggered. The size of the functor is
	// defined as a template argument, so it can be of any size. It also doesn't
	// use C++ exceptions.
	//
	// License:
	// Public Domain. Feel free to copy, distribute, and modify this file as you see fit.

	#include <cassert>
	#include <cstddef>
	#include <cstdint>
	#include <cstdio>

	#include <array>
	#include <atomic>
	//
	// Simple allocator for small memory blocks (from 1 to 255 bytes).
	// It keeps freelists of small blocks, built on top of 8K pages.
	// The allocator only grows - empty pages are never freed back
	// to the system.
	//
	// This allocator could easily be made lockless with atomic freelists.
	//

	#include <cstdint>
	//
	// General purpose minimal heap allocator.
	//
	// Keeps a freelist of chunks of arbitrary size. First round of allocations
	// will use the whole heap block before it starts going into the freelist.
	// Freeing just pushes the block back into the freelist and is constant time.
	// Allocating might search the freelist if the whole heap was already allocated
	// once.
	//
	// To reduce fragmentation we could merge free nodes either on free or allocate.

	// ----------------------------------------------------------------------------
	// c++ -std=c++11 -Wall -Wextra -Wshadow -Wunused -pedantic -fsanitize=address -fno-omit-frame-pointer asan_guarded_allocator.cpp

	#include <cassert>
	#include <cstdio>
	#include <cstdint>
	#include <cstdlib>
	#include <unordered_map>
	// Mostly complete and usable C++ version of Rust's Option<T> and Result<T,E> using only standard C++14, for fun.
	// This code is in the public domain.

	///////////////////////////////////////////////////////////////////////////////
	// Option.hpp
	///////////////////////////////////////////////////////////////////////////////
	#pragma once

	// ----------------------------------------------------------------------------
	// Includes
	#include <cassert>
	#include <cstdint>
	#include <cstdarg>
	#include <cstdio>
	#include <cmath>

	#define WIN32_LEAN_AND_MEAN
	#include <Windows.h>
	#include <intrin.h>