TypeTracker.hpp

Track class types abstractly to dynamically call correct function overloads.

TypeTracker is a templated class that must be declared with all of the types that can possibly be tracked. For example:

TypeTracker<int, std::string, double> tt;
…would create a TypeTracker that can manage the three types listed and convert back.

Todo:

Should use std::is_convertible<X,Y>::value to determine if casting on base type is allowed.

Functions should be able to have fixed type values mixed in.

Note

Status: BETA

struct TrackedInfo_Base
#include <TypeTracker.hpp>

The proxy base class of any type to be tracked.

Subclassed by TrackedInfo_Value< REAL_T, ID >

Public Functions

virtual size_t GetTypeID() const noexcept = 0
inline virtual ~TrackedInfo_Base()
virtual Ptr<TrackedInfo_Base> Clone() const = 0
struct TrackedVar
#include <TypeTracker.hpp>

The actual TrackedVar object that manages a Ptr to the value.

Public Functions

inline TrackedVar(Ptr<TrackedInfo_Base> _ptr)
inline TrackedVar(const TrackedVar &_in)

Copy constructor; use judiciously since it copies the contents!

inline TrackedVar(TrackedVar &&_in)

Move constructor takes control of the pointer.

inline ~TrackedVar()

Cleanup ptr on destruct.

inline TrackedVar &operator=(const TrackedVar &_in)

Move assignment hands over control of the pointer.

inline TrackedVar &operator=(TrackedVar &&_in)

Move assignment hands over control of the pointer.

inline size_t GetTypeID() const noexcept

Public Members

Ptr<TrackedInfo_Base> ptr
template<typename REAL_T, size_t ID>
struct TrackedInfo_Value : public TrackedInfo_Base
#include <TypeTracker.hpp>

TrackedInfo_Value store both the real type and an ID for it (to be identified from the base class for each conversion back.)

Public Types

using real_t = REAL_T
using this_t = TrackedInfo_Value<REAL_T, ID>

Public Functions

inline TrackedInfo_Value(const REAL_T &in)
inline TrackedInfo_Value(REAL_T &&in)
TrackedInfo_Value(const TrackedInfo_Value&) = default
TrackedInfo_Value(TrackedInfo_Value&&) = default
TrackedInfo_Value &operator=(const TrackedInfo_Value&) = default
TrackedInfo_Value &operator=(TrackedInfo_Value&&) = default
inline virtual size_t GetTypeID() const noexcept override
inline virtual Ptr<TrackedInfo_Base> Clone() const override

Build a copy of this TrackedInfo_Value; recipient is in charge of deletion.

Public Members

REAL_T value
template<typename ...TYPES>
class TypeTracker
#include <TypeTracker.hpp>

Dynamic functions that are indexed by parameter types; calls lookup the correct function to forward arguments into.

Public Types

using this_t = TypeTracker<TYPES...>
template<typename REAL_T>
using wrap_t = TrackedInfo_Value<REAL_T, get_type_index<REAL_T, TYPES...>()>
template<typename T>
using var_decoy = TrackedVar

var_decoy converts any variable into a TrackedVar (used to have correct number of vars)

Public Functions

TypeTracker() = default
TypeTracker(const TypeTracker&) = default
TypeTracker(TypeTracker&&) = default
TypeTracker &operator=(const TypeTracker&) = default
TypeTracker &operator=(TypeTracker&&) = default
inline ~TypeTracker()
template<typename ...Ts>
inline this_t &AddFunction(std::function<void(Ts...)> fun)

Add a new std::function that this TypeTracker should call if the appropriate types are passed in.

template<typename ...Ts>
inline this_t &AddFunction(void (*fun)(Ts...))

Add a new function pointer that this TypeTracker should call if the appropriate types are passed in.

template<typename LAMBDA_T>
inline this_t &AddFunction(const LAMBDA_T &fun)

Add a new lambda function that this TypeTracker should call if the appropriate types are passed in.

template<typename ...Ts>
inline void RunFunction(Ts&&... args)

Run the appropriate function based on the argument types received.

template<typename ...Ts>
inline void operator()(Ts&&... args)

Call TypeTracker as a function (refers call to RunFunction)

Public Static Functions

static inline constexpr size_t GetNumTypes()

How many types are we working with?

static inline constexpr size_t GetNumCombos(size_t vals = 2)

How many combinations of V types are there?

static inline constexpr size_t GetCumCombos(size_t vals = 2)

How many combinations are the of the given number of types OR FEWER?

template<typename T>
static inline constexpr size_t GetID()

Each type should have a unique ID.

template<typename T1, typename T2, typename ...Ts>
static inline constexpr size_t GetID()

Each set of types should have an ID unique within that number of types.

template<typename ...Ts>
static inline constexpr size_t GetComboID()

A ComboID should be unique across all size combinations.

static inline size_t GetTrackedID(const TrackedVar &tt)

A Tracked ID is simply the unique ID of the type being tracked.

template<typename ...Ts>
static inline size_t GetTrackedID(const TrackedVar &tt1, const TrackedVar &tt2, const Ts&... ARGS)

Or set of types being tracked…

template<typename ...Ts>
static inline constexpr size_t GetTrackedComboID(const Ts&... ARGS)

A tracked COMBO ID, is an ID for this combination of types, unique among all possible type combinations. Consistent with GetComboID with the same underlying types.

template<typename REAL_T>
static inline TrackedVar Convert(const REAL_T &val)

Convert an input value into a TrackedInfo_Value maintaining the value (universal version)

template<typename TEST_T>
static inline bool IsType(TrackedVar &tt)

Test if the tracked type is TEST_T.

template<typename REAL_T>
static inline REAL_T ToType(TrackedVar &tt)

Convert the tracked type back to REAL_T. Assert that this is type safe!

template<typename OUT_T>
static inline OUT_T Cast(TrackedVar &tt)

Cast the tracked type to OUT_T. Try to do so even if NOT original type!

Protected Attributes

std::unordered_map<size_t, Ptr<GenericFunction>> fun_map

fun_map is a hash table that maps a set of inputs to the appropriate function.