BinaryExpressionImpl.cc

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* BinaryExpressionImpl.cc                                     (C) 2000-2007 */
/*                                                                           */
/* Implementation of a binary expression.                                    */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
 
#include "arcane/expr/BinaryExpressionImpl.h"
#include "arcane/expr/OperatorMng.h"
#include "arcane/expr/BadOperationException.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
BinaryExpressionImpl::
BinaryExpressionImpl(IExpressionImpl* first, IExpressionImpl* second,
                     eOperationType operation)
: ExpressionImpl()
, m_first(first)
, m_second(second)
, m_operation(operation)
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
String BinaryExpressionImpl::
operationName(eOperationType type)
{
  switch (type) {
  case Add:
    return "Add";
  case Substract:
    return "Substract";
  case Multiply:
    return "Multiply";
  case Divide:
    return "Divide";
  case Minimum:
    return "Minimum";
  case Maximum:
    return "Maximum";
  case Pow:
    return "Pow";
  case LessThan:
    return "LessThan";
  case GreaterThan:
    return "GreaterThan";
  case LessOrEqualThan:
    return "LessOrEqualThan";
  case GreaterOrEqualThan:
    return "GreaterOrEqualThan";
  default:
    return "Unknown";
  }
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void BinaryExpressionImpl::
apply(ExpressionResult* result)
{
  /*
    cerr << ">> BEGIN BINARY EXPRESSION " 
    << operationName() << " [" << *result << "]\n";
  */
 
  // calculate the left and right expressions
  ExpressionResult first_op(result->indices());
  m_first->apply(&first_op);
  ExpressionResult second_op(result->indices());
  m_second->apply(&second_op);
 
  // search for the operator based on the expected type in the result
  VariantBase::eType type = first_op.data()->type();
  BinaryOperator* op = m_op_mng->find(this, type, m_operation);
  if (!op)
    throw BadOperationException("BinaryExpressionImpl::apply",
                                operationName(), type);
 
  op->evaluate(result, first_op.data(), second_op.data());
 
  /*
    cerr << "<< END BINARY EXPRESSION " 
    << operationName() << " [" << *result << "]\n";
  */
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/