tim::operation::generic_operator< Tp, Op, Tag > Struct Template Reference

This operation class is similar to pointer_operator but can handle non-pointer types. More...

#include "timemory/operations/types/generic.hpp"

Collaboration diagram for tim::operation::generic_operator< Tp, Op, Tag >:

Public Types
using	type = std::remove_pointer_t< Tp >

Public Member Functions
	TIMEMORY_DELETED_OBJECT (generic_operator) private
template<typename Up , typename... Args, typename Rp = type, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t< std::is_pointer< Up >::value, int > = 0>
	generic_operator (Up obj, Args &&... args)
template<typename Up , typename... Args, typename Rp = type, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t< std::is_pointer< Up >::value, int > = 0>
	generic_operator (Up obj, Up rhs, Args &&... args)
template<typename Up , typename... Args, typename Rp = Tp, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t<!std::is_pointer< Up >::value, int > = 0>
	generic_operator (Up &obj, Args &&... args)
template<typename Up , typename... Args, typename Rp = Tp, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t<!std::is_pointer< Up >::value, int > = 0>
	generic_operator (Up &obj, Up &rhs, Args &&... args)
template<typename Up , typename... Args, typename Rp = Tp, enable_if_t<!trait::is_available< Rp >::value, int > = 0>
	generic_operator (Up &, Args &&...)

Static Public Member Functions
template<typename Up >
static bool	is_invalid (Up &obj)

Detailed Description

template<typename Tp, typename Op, typename Tag>
struct tim::operation::generic_operator< Tp, Op, Tag >

This operation class is similar to pointer_operator but can handle non-pointer types.

Definition at line 54 of file generic.hpp.

Member Typedef Documentation

type

template<typename Tp , typename Op , typename Tag >

using tim::operation::generic_operator< Tp, Op, Tag >::type = std::remove_pointer_t<Tp>

Definition at line 56 of file generic.hpp.

Constructor & Destructor Documentation

generic_operator() [1/5]

template<typename Tp , typename Op , typename Tag >

template<typename Up , typename... Args, typename Rp = type, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t< std::is_pointer< Up >::value, int > = 0>

tim::operation::generic_operator< Tp, Op, Tag >::generic_operator ( Up  obj, Args &&...  args  )

inlineexplicit

Definition at line 109 of file generic.hpp.

    {
        // rely on compiler to optimize this away if supports_runtime_checks if false
        if(!check<Up>())
            return;
 
        // check the component is valid before applying
        if(obj && !is_invalid(*obj))
            sfinae(obj, 0, 0, 0, std::forward<Args>(args)...);
    }

References tim::operation::generic_operator< Tp, Op, Tag >::is_invalid().

generic_operator() [2/5]

template<typename Tp , typename Op , typename Tag >

template<typename Up , typename... Args, typename Rp = type, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t< std::is_pointer< Up >::value, int > = 0>

tim::operation::generic_operator< Tp, Op, Tag >::generic_operator ( Up  obj, Up  rhs, Args &&...  args  )

inlineexplicit

Definition at line 123 of file generic.hpp.

    {
        // rely on compiler to optimize this away if supports_runtime_checks if false
        if(!check<Up>())
            return;
 
        // check the components are valid before applying
        if(obj && rhs && !is_invalid(*obj) && !is_invalid(*rhs))
            sfinae(obj, rhs, 0, 0, 0, std::forward<Args>(args)...);
    }

References tim::operation::generic_operator< Tp, Op, Tag >::is_invalid().

generic_operator() [3/5]

template<typename Tp , typename Op , typename Tag >

template<typename Up , typename... Args, typename Rp = Tp, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t<!std::is_pointer< Up >::value, int > = 0>

tim::operation::generic_operator< Tp, Op, Tag >::generic_operator ( Up &  obj, Args &&...  args  )

inlineexplicit

Definition at line 199 of file generic.hpp.

    {
        // rely on compiler to optimize this away if supports_runtime_checks if false
        if(!check<Up>())
            return;
 
        // check the component is valid before applying
        if(!is_invalid(obj))
            sfinae(obj, 0, 0, 0, std::forward<Args>(args)...);
    }

References tim::operation::generic_operator< Tp, Op, Tag >::is_invalid().

generic_operator() [4/5]

template<typename Tp , typename Op , typename Tag >

template<typename Up , typename... Args, typename Rp = Tp, enable_if_t< trait::is_available< Rp >::value, int > = 0, enable_if_t<!std::is_pointer< Up >::value, int > = 0>

tim::operation::generic_operator< Tp, Op, Tag >::generic_operator ( Up &  obj, Up &  rhs, Args &&...  args  )

inlineexplicit

Definition at line 213 of file generic.hpp.

    {
        // rely on compiler to optimize this away if supports_runtime_checks if false
        if(!check<Up>())
            return;
 
        // check the components are valid before applying
        if(!is_invalid(obj) && !is_invalid(rhs))
            sfinae(obj, rhs, 0, 0, 0, std::forward<Args>(args)...);
    }

References tim::operation::generic_operator< Tp, Op, Tag >::is_invalid().

generic_operator() [5/5]

template<typename Tp , typename Op , typename Tag >

template<typename Up , typename... Args, typename Rp = Tp, enable_if_t<!trait::is_available< Rp >::value, int > = 0>

tim::operation::generic_operator< Tp, Op, Tag >::generic_operator ( Up &  , Args &&  ...  )

inline

Definition at line 307 of file generic.hpp.

    {}

Member Function Documentation

is_invalid()

template<typename Tp , typename Op , typename Tag >

template<typename Up >

static bool tim::operation::generic_operator< Tp, Op, Tag >::is_invalid ( Up &  obj )

inlinestatic

Definition at line 89 of file generic.hpp.

    {
        // use a type-list for checking multiple types
        using passthrough_t =
            type_list<operation::set_is_invalid<Tp>, operation::get_is_invalid<Tp, false>,
                      operation::get_is_invalid<Tp, true>>;
        if(is_one_of<Op, passthrough_t>::value)
            return false;
        return operation::get_is_invalid<Tp, false>{}(obj);
    }

Referenced by tim::operation::generic_operator< Tp, Op, Tag >::generic_operator().

TIMEMORY_DELETED_OBJECT()

template<typename Tp , typename Op , typename Tag >

tim::operation::generic_operator< Tp, Op, Tag >::TIMEMORY_DELETED_OBJECT ( generic_operator< Tp, Op, Tag >  )

inline

Definition at line 58 of file generic.hpp.

       :
    template <typename Up>
    static bool check()
    {
        using U = std::decay_t<std::remove_pointer_t<Up>>;
        static_assert(std::is_same<U, type>::value, "Error! Up != type");
 
        // this is commented out because generic_operator does work with non-component
        // types
        // static_assert(
        //     concepts::is_component<U>::value,
        //     "Error! Applying generic_operator on a type that is not a component");
 
        constexpr bool supports_runtime_checks = trait::runtime_enabled<Tp>::value &&
                                                 trait::runtime_enabled<Op>::value &&
                                                 trait::runtime_enabled<Tag>::value;
 
        // if runtime checks are enabled and type or tag is not enabled, return false
        if(supports_runtime_checks &&
           (!trait::runtime_enabled<Tp>::get() || !trait::runtime_enabled<Tag>::get()))
            return false;
 
        // if supports_runtime_checks if false, compiler should optimize away this entire
        // function call because it will be known at compile time that this function will
        // always returns true
        return true;
    }

---

The documentation for this struct was generated from the following files:

• timemory/operations/types.hpp
• timemory/operations/types/generic.hpp