fwd.hpp

#ifndef ENTT_ENTITY_FWD_HPP
#define ENTT_ENTITY_FWD_HPP
 
#include <memory>
#include "../core/fwd.hpp"
#include "utility.hpp"
 
namespace entt {
 
template<typename Entity, typename = std::allocator<Entity>>
class basic_sparse_set;
 
template<typename, typename Type, typename = std::allocator<Type>, typename = void>
class basic_storage;
 
template<typename>
class basic_registry;
 
template<typename, typename, typename, typename = void>
class basic_view;
 
template<typename>
struct basic_runtime_view;
 
template<typename, typename, typename, typename>
class basic_group;
 
template<typename>
class basic_observer;
 
template<typename>
class basic_organizer;
 
template<typename, typename...>
struct basic_handle;
 
template<typename>
class basic_snapshot;
 
template<typename>
class basic_snapshot_loader;
 
template<typename>
class basic_continuous_loader;
 
enum class entity : id_type {};
 
using sparse_set = basic_sparse_set<entity>;
 
template<typename... Args>
using storage = basic_storage<entity, Args...>;
 
using registry = basic_registry<entity>;
 
using observer = basic_observer<entity>;
 
using organizer = basic_organizer<entity>;
 
using handle = basic_handle<entity>;
 
using const_handle = basic_handle<const entity>;
 
template<typename... Args>
using handle_view = basic_handle<entity, Args...>;
 
template<typename... Args>
using const_handle_view = basic_handle<const entity, Args...>;
 
using snapshot = basic_snapshot<entity>;
 
using snapshot_loader = basic_snapshot_loader<entity>;
 
using continuous_loader = basic_continuous_loader<entity>;
 
template<typename Get, typename Exclude = exclude_t<>>
using view = basic_view<entity, Get, Exclude>;
 
using runtime_view = basic_runtime_view<sparse_set>;
 
template<typename... Args>
using group = basic_group<entity, Args...>;
 
} // namespace entt
 
#endif