StackElement.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id$
#ifndef EXPRESSIONEVALUATION_STACKELEMENT_H
#define EXPRESSIONEVALUATION_STACKELEMENT_H
 
// System include(s):
#include <iosfwd>
#include <vector>
#include <string>
#include <atomic>
 
// Local include(s):
#include "ExpressionEvaluation/IProxyLoader.h"
#include "ExpressionEvaluation/IAccessor.h"
#include "ExpressionEvaluation/PointerCache.h"
#include "CxxUtils/checker_macros.h"
 
class EventContext;

namespace ExpressionParsing {
 
   // Forward declaration(s):
   class IProxyLoader;

   class StackElement {

      friend std::ostream& operator<<( std::ostream& os,
                                       const StackElement& el );
 
   public:
      enum ElementType {
         SE_UNK       = 0, 
         SE_INT       = 1, 
         SE_DOUBLE    = 2, 
         SE_VECINT    = 3, 
         SE_VECDOUBLE = 4  
      };


      StackElement() {};
      StackElement( unsigned int val ) : m_type( SE_INT ), m_intVal(static_cast<unsigned int>(val)) {}
      StackElement( int val )  : m_type( SE_INT ), m_intVal(val) {}
      StackElement( double val ) : m_type( SE_DOUBLE ), m_doubleVal( val ) {}
      StackElement( const std::vector< int >& val ) : m_type( SE_VECINT ), m_vecIntVal(val) {}
      StackElement( const std::vector< double >& val ) : m_type( SE_VECDOUBLE ), m_vecDoubleVal( val ) {}
      StackElement( std::vector< int >&& val ) : m_type( SE_VECINT ), m_vecIntVal(std::move(val)) {}
      StackElement( std::vector< double >&& val ) : m_type( SE_VECDOUBLE ), m_vecDoubleVal( std::move(val) ) {}
      StackElement( const std::string& val, IProxyLoader* proxyLoader ) : /*m_type( SE_UNK ), */m_varName( val ), m_proxyLoader( proxyLoader ) {}
;
      StackElement(const StackElement &a);
      StackElement(StackElement &&a);


      StackElement& operator=( int rhs );
      StackElement& operator=( double rhs );
      StackElement& operator=( const std::vector< int >& rhs );
      StackElement& operator=( const std::vector< double >& rhs );
      StackElement& operator=( std::vector< int >&& rhs );
      StackElement& operator=( std::vector< double >&& rhs );
 
      StackElement& operator=( StackElement&& rhs );


      StackElement operator!();
      StackElement operator-();



      StackElement& operator-=( StackElement& rhs );
      template< typename T >
      StackElement& operator-=( const T& rhs );
      template< typename T >
      StackElement& operator-=( const std::vector< T >& rhs );
      StackElement& operator+=( StackElement& rhs );
      template< typename T >
      StackElement& operator+=( const T& rhs );
      template< typename T >
      StackElement& operator+=( const std::vector< T >& rhs );
      StackElement& operator*=( StackElement& rhs );
      template< typename T >
      StackElement& operator*=( const T& rhs );
      template< typename T >
      StackElement& operator*=( const std::vector< T >& rhs );
      StackElement& operator/=( StackElement& rhs );
      template< typename T >
      StackElement& operator/=( const T& rhs );
      template< typename T >
      StackElement& operator/=( const std::vector< T >& rhs );

      StackElement operator-( StackElement& rhs );
      template< typename T >
      StackElement operator-( const T& rhs );
      StackElement operator+( StackElement& rhs );
      template< typename T >
      StackElement operator+( const T& rhs );
      StackElement operator*( StackElement& rhs );
      template< typename T >
      StackElement operator*( const T& rhs );
      StackElement operator/( StackElement& rhs );
      template< typename T >
      StackElement operator/( const T& rhs );



      ElementType getType() const;
      bool isScalar() const;
      bool isVector() const;
      bool isProxy() const;
 
      const std::string& proxyVarName() const { return m_varName; }

      int asInt() const;
      bool asBool() const;

      template< typename T >
      T scalarValue() const;
      template< typename T >
      std::vector< T > vectorValue( std::size_t sizeIfScalar = 0 );



      void makeInt();
      void makeDouble();
      void makeVector( std::size_t n );

      StackElement valueFromProxy(const EventContext& ctx) const;

   private:
      template <class T_CompHelper>
      StackElement _comparisonOp(StackElement &other, T_CompHelper comp_helper);
   public:
      StackElement _eq(StackElement &other);
      StackElement _neq(StackElement &other);
      StackElement _and(StackElement &other);
      StackElement _or(StackElement &other);
      StackElement _gt(StackElement &other);
      StackElement _gte(StackElement &other);
      StackElement _lt(StackElement &other);
      StackElement _lte(StackElement &other);



      template< typename T >
      StackElement _pow( const T& n );
      StackElement _sum();
      StackElement _count();
      StackElement _abs();
      StackElement _sqrt();
      StackElement _cbrt();
      StackElement _sin();
      StackElement _cos();
      StackElement _tan();
      StackElement _asin();
      StackElement _acos();
      StackElement _atan();
      StackElement _sinh();
      StackElement _cosh();
      StackElement _tanh();
      StackElement _asinh();
      StackElement _acosh();
      StackElement _atanh();
      StackElement _log();
      StackElement _exp();

 
   private:
 
      void makeVectorIfNecessary( const StackElement& other );
      void makeVectorIfNecessary( const std::vector< int >& other );
      void makeVectorIfNecessary( const std::vector< double >& other );
 
      void makeDoubleIfNecessary( const StackElement& other );
      void makeDoubleIfNecessary( int other );
      void makeDoubleIfNecessary( double other );
      void makeDoubleIfNecessary( const std::vector< int >& other );
      void makeDoubleIfNecessary( const std::vector< double >& other );
 
      void ensureCompatible( const StackElement& other ) const;
      template< typename T >
      void ensureCompatibleVectors( const T& other ) const;
      template< typename T >
      void ensureCompatibleVectors( const std::vector< T >& other ) const;
 
      size_t size() const;
 
      ElementType m_type = SE_UNK;

      int m_intVal = 0;
      double m_doubleVal = 0.;
      std::vector< int > m_vecIntVal;
      std::vector< double > m_vecDoubleVal;

      std::string m_varName;
      IProxyLoader* m_proxyLoader = nullptr;
      mutable std::atomic<IAccessor::VariableType> m_variableType = IProxyLoader::VT_UNK;
      mutable PointerCache<IAccessor, std::memory_order_seq_cst> m_accessor ATLAS_THREAD_SAFE;
      mutable std::atomic<bool> m_moved = false;
 
   }; // class StackElement

   std::ostream& operator<<( std::ostream& os, const StackElement& el );
 
} // namespace ExpressionParsing

#include "ExpressionEvaluation/StackElement.icc"
 
#endif // EXPRESSIONEVALUATION_STACKELEMENT_H