luci::NodeFiller< ARG_TYPE_1, ARG_TYPE_2 > Class Template Reference

#include <NodeFiller.h>

Public Member Functions
	NodeFiller (ARG_TYPE_1 **arg_1, ARG_TYPE_2 **arg_2)
template<class COMM_NODE >
bool	with_commutative_args_of (const COMM_NODE *node)
template<class COMM_NODE >
bool	with_args_of (const COMM_NODE *node)

Detailed Description

template<class ARG_TYPE_1, class ARG_TYPE_2>
class luci::NodeFiller< ARG_TYPE_1, ARG_TYPE_2 >

INTRODUCTION Binary operation f(x,y) is 'commutative' when f(x,y) == f(y,x) holds for all x, y. For examples, ADD, MUL and SQUARED_DIFFERENCE are commutative. These helpers make it easy to find commutative arguments of commutative node.

HOW TO USE COMM_NODE *node; ARG_TYPE_1 *arg1; ARG_TYPE_2 *arg2;

bool ok = fill(&arg1, &arg2).with_commutative_args_of(node);

Result If 'node's commutative argument types are actually {ARG_TYPE_1, ARG_TYPE_2} (as a set), 'arg1' and 'arg2' set as actual 'node's arguments with matching type, and return value 'ok' is true. Otherwise, 'arg1' and 'arg2' not changed, 'ok' is false.

Definition at line 41 of file NodeFiller.h.

Constructor & Destructor Documentation

NodeFiller()

template<class ARG_TYPE_1 , class ARG_TYPE_2 >

luci::NodeFiller< ARG_TYPE_1, ARG_TYPE_2 >::NodeFiller ( ARG_TYPE_1 **  arg_1, ARG_TYPE_2 **  arg_2  )

inline

Definition at line 44 of file NodeFiller.h.

                                                     : _arg_1(arg_1), _arg_2(arg_2)
  {
    // DO NOTHING
  }

Member Function Documentation

with_args_of()

template<class ARG_TYPE_1 , class ARG_TYPE_2 >

template<class COMM_NODE >

bool luci::NodeFiller< ARG_TYPE_1, ARG_TYPE_2 >::with_args_of

(

const COMM_NODE *

node

)

Note

Similar as with_commutative_args_of but not commutative. _arg_1 and _arg_2 must match that of ARG_TYPE_1 and ARG_TYPE_2.

Definition at line 112 of file NodeFiller.h.

{
  // X == ARG_TYPE_1 / Y == ARG_TYPE_2
  {
    auto x = dynamic_cast<ARG_TYPE_1 *>(node->x());
    auto y = dynamic_cast<ARG_TYPE_2 *>(node->y());
 
    if (x && y)
    {
      *_arg_1 = x;
      *_arg_2 = y;
      return true;
    }
  }
 
  return false;
}

with_commutative_args_of()

template<class ARG_TYPE_1 , class ARG_TYPE_2 >

template<class COMM_NODE >

bool luci::NodeFiller< ARG_TYPE_1, ARG_TYPE_2 >::with_commutative_args_of

(

const COMM_NODE *

node

)

Returns

true When 'node's argument types are 'ARG_TYPE_1' and 'ARG_TYPE_2' In such case, it assign '_arg_1' and '_arg_2' to actual arguments

false When 'node's argument types are NOT matched with 'ARG_TYPE_*' In such case, it does not amend '_arg_1' and '_arg_2'

@require COMM_NODE has member x() and y()

Definition at line 79 of file NodeFiller.h.

{
  // Case 1) X == ARG_TYPE_1 / Y == ARG_TYPE_2
  {
    auto x = dynamic_cast<ARG_TYPE_1 *>(node->x());
    auto y = dynamic_cast<ARG_TYPE_2 *>(node->y());
 
    if (x && y)
    {
      *_arg_1 = x;
      *_arg_2 = y;
      return true;
    }
  }
 
  // Case 2) X == ARG_TYPE_2 / Y == ARG_TYPE_1
  {
    auto x = dynamic_cast<ARG_TYPE_2 *>(node->x());
    auto y = dynamic_cast<ARG_TYPE_1 *>(node->y());
 
    if (x && y)
    {
      *_arg_1 = y;
      *_arg_2 = x;
      return true;
    }
  }
 
  return false;
}

---

The documentation for this class was generated from the following file:

• compiler/luci/pass/src/helpers/NodeFiller.h