OperatorMng.h

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* OperatorMng.h                                               (C) 2000-2004 */
/*                                                                           */
/* Stores all possible operator types on expressions.                        */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_OPERATORMNG_H
#define ARCANE_UTILS_OPERATORMNG_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/expr/UnaryExpressionImpl.h"
#include "arcane/expr/BinaryExpressionImpl.h"
#include "arcane/expr/WhereExpressionImpl.h"
#include "arcane/expr/LitteralExpressionImpl.h"
 
//%% ARCANE_EXPR_SUPPRESS_BEGIN
#include "arcane/VariableExpressionImpl.h"
//%% ARCANE_EXPR_SUPPRESS_END
 
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_EXPR_EXPORT OperatorMng
{
 protected:
 
  OperatorMng();
  ~OperatorMng();
 
 public:
 
  static OperatorMng* instance();
 
 public:
 
  UnaryOperator* find(UnaryExpressionImpl* e,
                      VariantBase::eType type,
                      UnaryExpressionImpl::eOperationType operation);
 
  BinaryOperator* find(BinaryExpressionImpl* e,
                       VariantBase::eType type,
                       BinaryExpressionImpl::eOperationType operation);
 
  WhereOperator* find(WhereExpressionImpl* e,
                      VariantBase::eType type);
 
  LitteralOperator* find(LitteralExpressionImpl* e,
                         VariantBase::eType type);
 
  //%% ARCANE_EXPR_SUPPRESS_BEGIN
  VariableOperator* find(VariableExpressionImpl* e,
                         VariantBase::eType type);
  //%% ARCANE_EXPR_SUPPRESS_END
 
 private:
 
  static OperatorMng* m_instance;
 
 private:
 
  typedef std::map<VariantBase::eType, UnaryOperator*,
                   std::less<VariantBase::eType>>
  UnaryOpMap;
  UnaryOpMap m_unary_op[UnaryExpressionImpl::NbOperationType];
 
  typedef std::map<VariantBase::eType, BinaryOperator*,
                   std::less<Integer>>
  BinaryOpMap;
  BinaryOpMap m_binary_op[BinaryExpressionImpl::NbOperationType];
 
  typedef std::map<VariantBase::eType, WhereOperator*,
                   std::less<VariantBase::eType>>
  WhereOpMap;
  WhereOpMap m_where_op;
 
  typedef std::map<VariantBase::eType, LitteralOperator*,
                   std::less<VariantBase::eType>>
  LitteralOpMap;
  LitteralOpMap m_litteral_op;
 
  //%% ARCANE_EXPR_SUPPRESS_BEGIN
  typedef std::map<VariantBase::eType, VariableOperator*,
                   std::less<VariantBase::eType>>
  VariableOpMap;
  VariableOpMap m_variable_op;
  //%% ARCANE_EXPR_SUPPRESS_END
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif