types.h File Reference

#include <initializer_list>
#include <unordered_set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <unordered_map>
#include <functional>
#include <fstream>
#include <algorithm>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include "utils.h"

Classes
struct	Engine::Rectangle< T >
struct	Engine::MasterLock

Namespaces
namespace	Engine
	API for creating Applications and rasterization-engines.

Typedefs
template<class C >
using	Engine::Initializer = std::initializer_list< C >
template<class C , size_t N>
using	Engine::Array = std::array< C, N >
template<class C >
using	Engine::HeapArray = std::vector< C >
template<class C >
using	Engine::HeapArray2D = std::vector< std::vector< C > >
template<class C >
using	Engine::List = std::list< C >
template<class C >
using	Engine::Queue = std::queue< C >
template<class C >
using	Engine::Stack = std::stack< C >
template<class C >
using	Engine::UnorderedSet = std::unordered_set< C >
template<class C >
using	Engine::Function = std::function< C >
using	Engine::String = std::string
using	Engine::StringStream = std::stringstream
using	Engine::InputStringStream = std::istringstream
using	Engine::OutputStringStream = std::ostringstream
using	Engine::InputFfileStream = std::ifstream
template<class A , class B >
using	Engine::Pair = std::pair< A, B >
template<class A , class B >
using	Engine::UnorderedMap = std::unordered_map< A, B >
template<class A , class B >
using	Engine::OrderedMap = std::map< A, B >
using	Engine::Thread = std::thread
using	Engine::Mutex = std::mutex
using	Engine::RecursiveMutex = std::recursive_mutex
using	Engine::ConditionalVariable = std::condition_variable
template<class C >
using	Engine::UniqueLock = std::unique_lock< C >
typedef UnorderedSet< std::string >	Engine::StringUnorderedSet
typedef UnorderedMap< int, bool >	Engine::StateEnabledUnorderedMap
typedef UnorderedMap< int, bool >	Engine::CapabilityUnorderedMap
typedef unsigned char	Engine::Byte
typedef HeapArray< Byte >	Engine::ByteArray
typedef unsigned short	Engine::ushort
typedef uint	Engine::TypeID
using	Engine::UintRectangle = Rectangle< uint >
using	Engine::FloatRectangle = Rectangle< float >
using	Engine::DoubleRectangle = Rectangle< double >
typedef uint	Engine::Handle
typedef Handle	Engine::ArrayIndex

Enumerations
enum	: uint { Engine::INVALID_HANDLE = std::numeric_limits< uint >::max() }