kddockwidgets/2.0.0/node__functions_8h_source.html

/*

  This file is part of KDBindings.


  SPDX-FileCopyrightText: 2021-2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>

  Author: Sean Harmer <sean.harmer@kdab.com>


  SPDX-License-Identifier: MIT


  Contact KDAB at <info@kdab.com> for commercial licensing options.

*/


#pragma once


#include <kdbindings/make_node.h>


#include <cmath>


namespace KDBindings {


namespace Private {


template<typename... Ts>

struct any_bindables;


// Check to see if a single type is a bindable (node or property)

template<typename T>


struct any_bindables<T> : is_bindable<T> {

};


// Check the head of the typelist and recurse

template<typename HEAD, typename... Ts>


struct any_bindables<HEAD, Ts...> : std::integral_constant<

                                            bool,

                                            any_bindables<HEAD>::value || any_bindables<Ts...>::value> {

};


} // namespace Private


#define KDBINDINGS_DECLARE_FUNCTION(NAME, FUNC)                                                                                                                                                       \

    template<typename... Ts>                                                                                                                                                                          \

    inline auto NAME(Ts &&...args)->std::enable_if_t<::KDBindings::Private::any_bindables<Ts...>::value, ::KDBindings::Private::Node<::KDBindings::Private::operator_node_result_t<decltype(FUNC), Ts...>>> \

    {                                                                                                                                                                                                 \

        return ::KDBindings::Private::makeNode(FUNC, std::forward<Ts>(args)...); \

    }


struct node_abs {

    template<typename... Ts>


    auto operator()(Ts &&...x) const

    {

        return std::abs(std::forward<Ts>(x)...);

    }


};


KDBINDINGS_DECLARE_FUNCTION(abs, node_abs{})


#define KDBINDINGS_DECLARE_FUNCTION_OBJECT(NAME, FUNCTION) \

    struct NAME {                                          \

        template<typename... Ts>                           \

        auto operator()(Ts &&...x) const                   \

        {                                                  \

            return FUNCTION(std::forward<Ts>(x)...);       \

        }                                                  \

    };


#define KDBINDINGS_DECLARE_NAMESPACED_FUNCTION(NAMESPACE, NAME)                  \

    KDBINDINGS_DECLARE_FUNCTION_OBJECT(node_##NAMESPACE_##NAME, NAMESPACE::NAME) \

    KDBINDINGS_DECLARE_FUNCTION(NAME, node_##NAMESPACE_##NAME{})


#define KDBINDINGS_DECLARE_STD_FUNCTION(NAME) \

    KDBINDINGS_DECLARE_NAMESPACED_FUNCTION(std, NAME)


// Define some common and useful functions

KDBINDINGS_DECLARE_STD_FUNCTION(floor)

KDBINDINGS_DECLARE_STD_FUNCTION(ceil)

KDBINDINGS_DECLARE_STD_FUNCTION(sin)

KDBINDINGS_DECLARE_STD_FUNCTION(cos)

KDBINDINGS_DECLARE_STD_FUNCTION(tan)

KDBINDINGS_DECLARE_STD_FUNCTION(asin)

KDBINDINGS_DECLARE_STD_FUNCTION(acos)

KDBINDINGS_DECLARE_STD_FUNCTION(atan)


} // namespace KDBindings

make_node.h

KDBindings::Private::operator_node_result_t
typename operator_node_result< Operator, Ts... >::type operator_node_result_t
Definition make_node.h:57

KDBindings
The main namespace of the KDBindings library.
Definition binding.h:21

KDBINDINGS_DECLARE_FUNCTION_OBJECT
#define KDBINDINGS_DECLARE_FUNCTION_OBJECT(NAME, FUNCTION)
This macro declares a callable struct that wraps a function with all its overloads.
Definition node_functions.h:100

KDBINDINGS_DECLARE_FUNCTION
#define KDBINDINGS_DECLARE_FUNCTION(NAME, FUNC)
KDBINDINGS_DECLARE_FUNCTION is a helper macro to declare and define functions for use in data binding...
Definition node_functions.h:54

KDBINDINGS_DECLARE_STD_FUNCTION
#define KDBINDINGS_DECLARE_STD_FUNCTION(NAME)
This macro is based on KDBINDINGS_DECLARE_NAMESPACED_FUNCTION(NAMESPACE, FUNC) to make it easier to d...
Definition node_functions.h:136

KDBindings::Private::any_bindables
Definition node_functions.h:23

KDBindings::node_abs
An example struct that is used with a call to KDBINDINGS_DECLARE_FUNCTION to declare all overloads of...
Definition node_functions.h:72

KDBindings::node_abs::operator()
auto operator()(Ts &&...x) const
The operator() is overloaded so the struct can be used as a function object.
Definition node_functions.h:80