type.h File Reference

#include "sen/core/base/assert.h"
#include "sen/core/base/class_helpers.h"
#include "sen/core/base/hash32.h"
#include "sen/core/base/result.h"
#include "sen/core/base/strong_type.h"
#include "sen/core/base/type_traits_extra.h"
#include "sen/core/meta/detail/type_impl.h"
#include "sen/core/meta/detail/types_fwd.h"
#include <cassert>
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string_view>
#include <type_traits>
#include <variant>

Go to the source code of this file.

Classes
struct	sen::MemberHash
	The hash of a member. More...
struct	sen::ShouldBePassedByValue< MemberHash >
class	sen::Type
	Represents a type that can be used to define variables and arguments for methods or functions. Types use the GoF Visitor pattern in order to allow easy and fast operation, as double dispatching is faster and cleaner than a (dynamic) cast-based approach. More...
class	sen::TypeHandle< SenTypeType >
	Handle around a type that, by default, ensures the lifetime of the underlying type. More...
struct	std::hash< sen::TypeHandle< Type > >
struct	std::hash<::sen::MemberHash >

Namespaces
namespace	sen
namespace	std
	STL namespace.

Macros
#define	SEN_META_TYPE(classname)
	Helper macro to implement some type methods. Only to be used within this library. NOLINTNEXTLINE.

Typedefs
template<typename T>
using	sen::ConstSharedPtr = std::shared_ptr<const T>
	Utility typedef.
template<typename T = Type>
using	sen::ConstTypeHandle = TypeHandle<const T>
template<typename T = Type>
using	sen::MaybeConstTypeHandle = std::optional<ConstTypeHandle<T>>

Enumerations
enum class	sen::TransportMode : uint8_t { sen::TransportMode::unicast = 0U , sen::TransportMode::multicast = 1U , sen::TransportMode::confirmed = 2U }
	How to transport information. More...

Functions
template<typename T>
	sen::TypeHandle (std::shared_ptr< T > type) -> TypeHandle< T >
template<typename T>
TypeHandle< T >	sen::makeNonOwningTypeHandle (T *typePtr)
	Creates a non-owning type handle from a type pointer.
template<typename T, typename U>
std::optional< TypeHandle< T > >	sen::dynamicTypeHandleCast (const TypeHandle< U > &handle)
	Downcasts the type inside the type handle to the specified one, if possible.

Macro Definition Documentation

SEN_META_TYPE

#define SEN_META_TYPE

(

classname

)

Value:

public:                                                                                                                \
  SEN_NOCOPY_NOMOVE(classname)                                                                                         \
                                                                                                                       \
public:                                                                                                                \
  void accept(FullTypeVisitor& tv) const override { tv.apply(*this); }                                                 \
                                                                                                                       \
  [[nodiscard]] const classname* as##classname() const noexcept override { return this; }                              \
                                                                                                                       \
private:

Helper macro to implement some type methods. Only to be used within this library. NOLINTNEXTLINE.