ExpressionParsing::StackElement Class Reference

Class describing a single element in a text expression. More...

#include <StackElement.h>

Collaboration diagram for ExpressionParsing::StackElement:

Public Types
enum	ElementType {   SE_UNK = 0 , SE_INT = 1 , SE_DOUBLE = 2 , SE_VECINT = 3 ,   SE_VECDOUBLE = 4 }
	Type of the data held by this object. More...

Public Member Functions
template<>
std::vector< int >	vectorValue (std::size_t sizeIfScalar)
template<>
std::vector< double >	vectorValue (size_t sizeIfScalar)
template<>
StackElement	_pow (const StackElement &n)
template<>
void	ensureCompatibleVectors (const StackElement &other) const
Constructor definitions
	StackElement ()
	Default constructor.
	StackElement (unsigned int val)
	Constructor creating the object with an unsigned integer value.
	StackElement (int val)
	Constructor creating the object with a signed integer value.
	StackElement (double val)
	Constructor creating the object with a double value.
	StackElement (const std::vector< int > &val)
	Constructor creating the object with a vector of integers value.
	StackElement (const std::vector< double > &val)
	Constructor creating the object with a vector of doubles value.
	StackElement (std::vector< int > &&val)
	Constructor creating the object with a vector of integers value.
	StackElement (std::vector< double > &&val)
	Constructor creating the object with a vector of doubles value.
	StackElement (const std::string &val, IProxyLoader *proxyLoader)
	Constructor creating the object from a text expression.
	StackElement (const StackElement &a)
	StackElement (StackElement &&a)
Assignment operators
StackElement &	operator= (int rhs)
	Operator assigning an integer value to the object.
StackElement &	operator= (double rhs)
	Operator assigning a double value to the object.
StackElement &	operator= (const std::vector< int > &rhs)
	Operator assigning a vector of integers to the object.
StackElement &	operator= (const std::vector< double > &rhs)
	Operator assigning a vector of doubles to the object.
StackElement &	operator= (std::vector< int > &&rhs)
	Operator assigning a vector of integers to the object.
StackElement &	operator= (std::vector< double > &&rhs)
	Operator assigning a vector of doubles to the object.
StackElement &	operator= (StackElement &&rhs)
Comparison and logical operators
StackElement	operator! ()
	NOT operator.
StackElement	operator- ()
	Inverse operator.
Modifier operators
StackElement &	operator-= (StackElement &rhs)
	Subtract a scalar type from the object.
template<typename T>
StackElement &	operator-= (const T &rhs)
template<typename T>
StackElement &	operator-= (const std::vector< T > &rhs)
	Subtract a vector type from the object.
StackElement &	operator+= (StackElement &rhs)
	Add a scalar type to the object.
template<typename T>
StackElement &	operator+= (const T &rhs)
template<typename T>
StackElement &	operator+= (const std::vector< T > &rhs)
	Add a vector type to the object.
StackElement &	operator*= (StackElement &rhs)
	Multiply the object by a scalar type.
template<typename T>
StackElement &	operator*= (const T &rhs)
template<typename T>
StackElement &	operator*= (const std::vector< T > &rhs)
	Multiply the object by a vector type.
StackElement &	operator/= (StackElement &rhs)
	Divide the object by a scalar type.
template<typename T>
StackElement &	operator/= (const T &rhs)
template<typename T>
StackElement &	operator/= (const std::vector< T > &rhs)
	Divide the object by a vector type.
StackElement	operator- (StackElement &rhs)
	Operator subtracting a value from the object.
template<typename T>
StackElement	operator- (const T &rhs)
StackElement	operator+ (StackElement &rhs)
	Operator adding a value to the object.
template<typename T>
StackElement	operator+ (const T &rhs)
StackElement	operator* (StackElement &rhs)
	Operator multiplying the object by a value.
template<typename T>
StackElement	operator* (const T &rhs)
StackElement	operator/ (StackElement &rhs)
	Operator dividing the object by a value.
template<typename T>
StackElement	operator/ (const T &rhs)
Accessor functions
ElementType	getType () const
	Get the variable type of the object.
bool	isScalar () const
	Check if the object describes a scalar value.
bool	isVector () const
	Check if the object describes a vector value.
bool	isProxy () const
	Check if the object takes its value from a StoreGate object.
const std::string &	proxyVarName () const
int	asInt () const
	Get the internal value of the object as an integer.
bool	asBool () const
	Get the internal value of the object as a boolean.
template<typename T>
T	scalarValue () const
	Evaluate the value of the object into the requested scalar type.
template<typename T>
std::vector< T >	vectorValue (std::size_t sizeIfScalar=0)
	Evaluate the value of the object into the requested vector type.
Modifier functions
void	makeInt ()
	Function constructing internal integer values in case double values were given to the object initially.
void	makeDouble ()
	Function constructing internal double values in case integer values were given to the object initially.
void	makeVector (std::size_t n)
	Function converting a possibly scalar value into a vector.
StackElement	valueFromProxy (const EventContext &ctx) const
	Set the internal variables of the object based on the objects in SG.
Internal functions evaluating mathematical operations
template<typename T>
StackElement	_pow (const T &n)
	Function raising the object's value to the n'th power.
StackElement	_sum ()
	Function calculating a sum value.
StackElement	_count ()
	Function counting elements.
StackElement	_abs ()
	Function taking the absolute value of the object.
StackElement	_sqrt ()
	Function taking the square root of the object.
StackElement	_cbrt ()
	Function taking the cubic root of the object.
StackElement	_sin ()
	Function taking the sinus value of the object.
StackElement	_cos ()
	Function taking the cosine value of the object.
StackElement	_tan ()
	Function taking the tangent value of the object.
StackElement	_asin ()
	Function taking the arc sinus value of the object.
StackElement	_acos ()
	Function taking the arc cosine value of the object.
StackElement	_atan ()
	Function taking the arc tangent value of the object.
StackElement	_sinh ()
	Function taking the sinus hyperbolic value of the object.
StackElement	_cosh ()
	Function taking the cosine hyperbolic value of the object.
StackElement	_tanh ()
	Function taking the tangent hyperbolic value of the object.
StackElement	_asinh ()
	Function taking the arc sinus hyperbolic value of the object.
StackElement	_acosh ()
	Function taking the arc cosine hyperbolic value of the object.
StackElement	_atanh ()
	Function taking the arc tangent hyperbolic value of the object.
StackElement	_log ()
	Function taking the logarithm of the object.
StackElement	_exp ()
	Function taking the natural exponent of the object.

Private Member Functions
Internal operations on the object
void	makeVectorIfNecessary (const StackElement &other)
	The macro is not needed anymore:
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

Private Attributes
ElementType	m_type = SE_UNK
	The type of the variable held by the object.
int	m_intVal = 0
	The value of the object represented as an integer.
double	m_doubleVal = 0.
	The value of the object represented as a double.
std::vector< int >	m_vecIntVal
	The value of the object represented as a vector of integers.
std::vector< double >	m_vecDoubleVal
	The value of the object represented as a vector of doubles.
std::string	m_varName
	The name/definition of the variable.
IProxyLoader *	m_proxyLoader = nullptr
	Loader for the described variable.
std::atomic< IAccessor::VariableType >	m_variableType = IProxyLoader::VT_UNK
	Type of the variable provided by the proxy loader.
PointerCache< IAccessor, std::memory_order_seq_cst > m_accessor	ATLAS_THREAD_SAFE
std::atomic< bool >	m_moved = false
	Internal flag showing whether the type of the variable was already determined.

Friends
std::ostream &	operator<< (std::ostream &os, const StackElement &el)
	Declare the print operator as a friend of the class.

Internal functions evaluating binary comparisons
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<class T_CompHelper>
StackElement	_comparisonOp (StackElement &other, T_CompHelper comp_helper)

Detailed Description

Class describing a single element in a text expression.

A vector of such objects is used to describe a full text expression. As such, it's able to perform all the operations that can be described in a text expression. Most operations are destructive i.e. vector content will be modified and moved on operations. This is to reduce the number of vector copy operations. Thus, if the content should be preserved, a copy needs to be created and the operation should be applied to the copy.

Author

Thomas Gillam (thoma.nosp@m.s.gi.nosp@m.llam@.nosp@m.cern.nosp@m..ch)

$Revision$ $Date$

Definition at line 55 of file StackElement.h.

Member Enumeration Documentation

ElementType

enum ExpressionParsing::StackElement::ElementType

Type of the data held by this object.

Enumerator
SE_UNK	The type is not known, or not applicable.
SE_INT	The type is an integer.
SE_DOUBLE	The type is a double.
SE_VECINT	The type is a vector of integers.
SE_VECDOUBLE	The type is a vector of doubles.

Definition at line 63 of file StackElement.h.

                       {
         SE_UNK       = 0, 
         SE_INT       = 1, 
         SE_DOUBLE    = 2, 
         SE_VECINT    = 3, 
         SE_VECDOUBLE = 4  
      };

Constructor & Destructor Documentation

StackElement() [1/11]

ExpressionParsing::StackElement::StackElement ( )

inline

Default constructor.

Definition at line 75 of file StackElement.h.

{};

StackElement() [2/11]

ExpressionParsing::StackElement::StackElement ( unsigned int val )

inline

Constructor creating the object with an unsigned integer value.

Definition at line 77 of file StackElement.h.

: m_type( SE_INT ), m_intVal(static_cast<unsigned int>(val)) {}

StackElement() [3/11]

ExpressionParsing::StackElement::StackElement ( int val )

inline

Constructor creating the object with a signed integer value.

Definition at line 79 of file StackElement.h.

: m_type( SE_INT ), m_intVal(val) {}

StackElement() [4/11]

ExpressionParsing::StackElement::StackElement ( double val )

inline

Constructor creating the object with a double value.

Definition at line 81 of file StackElement.h.

: m_type( SE_DOUBLE ), m_doubleVal( val ) {}

StackElement() [5/11]

ExpressionParsing::StackElement::StackElement ( const std::vector< int > & val )

inline

Constructor creating the object with a vector of integers value.

Definition at line 83 of file StackElement.h.

: m_type( SE_VECINT ), m_vecIntVal(val) {}

StackElement() [6/11]

ExpressionParsing::StackElement::StackElement ( const std::vector< double > & val )

inline

Constructor creating the object with a vector of doubles value.

Definition at line 85 of file StackElement.h.

: m_type( SE_VECDOUBLE ), m_vecDoubleVal( val ) {}

StackElement() [7/11]

ExpressionParsing::StackElement::StackElement ( std::vector< int > && val )

inline

Constructor creating the object with a vector of integers value.

Definition at line 87 of file StackElement.h.

: m_type( SE_VECINT ), m_vecIntVal(std::move(val)) {}

StackElement() [8/11]

ExpressionParsing::StackElement::StackElement ( std::vector< double > && val )

inline

Constructor creating the object with a vector of doubles value.

Definition at line 89 of file StackElement.h.

: m_type( SE_VECDOUBLE ), m_vecDoubleVal( std::move(val) ) {}

StackElement() [9/11]

ExpressionParsing::StackElement::StackElement ( const std::string & val, IProxyLoader * proxyLoader )

inline

Constructor creating the object from a text expression.

Definition at line 91 of file StackElement.h.

: /*m_type( SE_UNK ), */m_varName( val ), m_proxyLoader( proxyLoader ) {}

StackElement() [10/11]

ExpressionParsing::StackElement::StackElement

(

const StackElement &

a

)

StackElement() [11/11]

ExpressionParsing::StackElement::StackElement

(

StackElement &&

a

)

Member Function Documentation

_abs()

StackElement ExpressionParsing::StackElement::_abs

(

)

Function taking the absolute value of the object.

Definition at line 614 of file StackElement.cxx.

                                   {
      if (this->m_moved) throw std::logic_error("Content already moved");
 
      StackElement temp(std::move(*this));
      this->m_moved=true;
      switch( m_type ) {
 
      case SE_INT:
         m_intVal = std::abs( temp.m_intVal );
         break;
 
      case SE_DOUBLE:
         m_doubleVal = std::abs( temp.m_doubleVal );
         break;
 
      case SE_VECINT:
         {
            for( int &value : temp.m_vecIntVal ) {
               value = std::abs( value );
            }
         }
         break;
 
      case SE_VECDOUBLE:
         {
            for( double &value : temp.m_vecDoubleVal ) {
               value = std::abs( value );
            }
         }
         break;
 
      default:
         // @throw exception ?
         break;
      }
      return temp;
   }

_acos()

StackElement ExpressionParsing::StackElement::_acos

(

)

Function taking the arc cosine value of the object.

_acosh()

StackElement ExpressionParsing::StackElement::_acosh

(

)

Function taking the arc cosine hyperbolic value of the object.

_and()

StackElement ExpressionParsing::StackElement::_and

(

StackElement &

other

)

Definition at line 520 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_and()); }

_asin()

StackElement ExpressionParsing::StackElement::_asin

(

)

Function taking the arc sinus value of the object.

_asinh()

StackElement ExpressionParsing::StackElement::_asinh

(

)

Function taking the arc sinus hyperbolic value of the object.

_atan()

StackElement ExpressionParsing::StackElement::_atan

(

)

Function taking the arc tangent value of the object.

_atanh()

StackElement ExpressionParsing::StackElement::_atanh

(

)

Function taking the arc tangent hyperbolic value of the object.

_cbrt()

StackElement ExpressionParsing::StackElement::_cbrt

(

)

Function taking the cubic root of the object.

_comparisonOp()

template<class T_CompHelper>

StackElement ExpressionParsing::StackElement::_comparisonOp ( StackElement & other, T_CompHelper comp_helper )

private

Definition at line 479 of file StackElement.cxx.

   {
      if (m_type ==SE_UNK || other.m_type==SE_UNK) {
         throw std::runtime_error( "ERROR: Can't operate on SE_UNK "
                                   "StackElements");
      }
      if( isScalar() && other.isScalar() ) {
         if( m_type == SE_INT  && other.m_type == SE_INT ) {
            return comp_helper.compare(scalarValue< int >(),other.scalarValue< int >() );
         } else {
            return comp_helper.compare(scalarValue< double >(),other.scalarValue< double >() );
         }
      } else {
         if (isVector() && other.isVector() && this->size() != other.size()) {
            throw std::runtime_error( "Incompatible vectors - different length" );
         }
         std::size_t the_size = ( m_type == SE_VECINT || m_type==SE_VECDOUBLE) ? this->size() : other.size();
         if(    ( m_type == SE_VECINT)
                && ( other.m_type == SE_VECINT || other.m_type == SE_INT )) {
            return compareVector( this->vectorValue<int>(the_size) , other.vectorValue< int >(the_size), comp_helper );
         }
         else if( m_type == SE_INT && other.m_type == SE_VECINT) {
            return compareVectorAlt( this->vectorValue<int>(the_size) , other.vectorValue< int >(the_size), comp_helper );
         }
         else {
            return compareVector( this->vectorValue<double>(the_size) , other.vectorValue< double >(the_size), comp_helper );
         }
      }
   }

_cos()

StackElement ExpressionParsing::StackElement::_cos

(

)

Function taking the cosine value of the object.

_cosh()

StackElement ExpressionParsing::StackElement::_cosh

(

)

Function taking the cosine hyperbolic value of the object.

_count()

StackElement ExpressionParsing::StackElement::_count

(

)

Function counting elements.

Definition at line 576 of file StackElement.cxx.

                                      {
 
      switch( m_type ) {
 
      case SE_INT:
         return !!( m_intVal );
         break;
 
      case SE_DOUBLE:
         return !!( m_doubleVal );
         break;
 
      case SE_VECINT:
         {
            int total = 0;
            for( int value : m_vecIntVal ) {
               total += !!value;
            }
            return total;
         }
         break;
 
      case SE_VECDOUBLE:
         {
            int total = 0;
            for( double value : m_vecDoubleVal ) {
               total += !!value;
            }
            return total;
         }
         break;
 
      default:
         return 0;
         break;
      }
   }

_eq()

StackElement ExpressionParsing::StackElement::_eq

(

StackElement &

other

)

Definition at line 518 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_eq()); }

_exp()

StackElement ExpressionParsing::StackElement::_exp

(

)

Function taking the natural exponent of the object.

_gt()

StackElement ExpressionParsing::StackElement::_gt

(

StackElement &

other

)

Definition at line 522 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_gt()); }

_gte()

StackElement ExpressionParsing::StackElement::_gte

(

StackElement &

other

)

Definition at line 523 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_gte()); }

_log()

StackElement ExpressionParsing::StackElement::_log

(

)

Function taking the logarithm of the object.

_lt()

StackElement ExpressionParsing::StackElement::_lt

(

StackElement &

other

)

Definition at line 524 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_lt()); }

_lte()

StackElement ExpressionParsing::StackElement::_lte

(

StackElement &

other

)

Definition at line 525 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_lte()); }

_neq()

StackElement ExpressionParsing::StackElement::_neq

(

StackElement &

other

)

Definition at line 519 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_neq()); }

_or()

StackElement ExpressionParsing::StackElement::_or

(

StackElement &

other

)

Definition at line 521 of file StackElement.cxx.

{ return _comparisonOp(b, Helper_or()); }

_pow() [1/2]

template<>

StackElement ExpressionParsing::StackElement::_pow

(

const StackElement &

n

)

Definition at line 529 of file StackElement.cxx.

                                                          {
 
      if( n.isVector() ) {
         throw std::runtime_error( "Can't use vector as exponent" );
      } else {
         return _pow( n.scalarValue< double >() );
      }
   }

_pow() [2/2]

template<typename T>

StackElement ExpressionParsing::StackElement::_pow

(

const T &

n

)

Function raising the object's value to the n'th power.

_sin()

StackElement ExpressionParsing::StackElement::_sin

(

)

Function taking the sinus value of the object.

_sinh()

StackElement ExpressionParsing::StackElement::_sinh

(

)

Function taking the sinus hyperbolic value of the object.

_sqrt()

StackElement ExpressionParsing::StackElement::_sqrt

(

)

Function taking the square root of the object.

_sum()

StackElement ExpressionParsing::StackElement::_sum

(

)

Function calculating a sum value.

Definition at line 538 of file StackElement.cxx.

                                   {
 
      switch( m_type ) {
 
      case SE_INT:
         return m_intVal;
         break;
 
      case SE_DOUBLE:
         return m_doubleVal;
         break;
 
      case SE_VECINT:
         {
            int total = 0;
            for( int value : m_vecIntVal ) {
               total += value;
            }
            return total;
         }
         break;
 
      case SE_VECDOUBLE:
         {
            double total = 0.0;
            for( double value : m_vecDoubleVal ) {
               total += value;
            }
            return total;
         }
         break;
 
      default:
         return 0;
         break;
      }
   }

_tan()

StackElement ExpressionParsing::StackElement::_tan

(

)

Function taking the tangent value of the object.

_tanh()

StackElement ExpressionParsing::StackElement::_tanh

(

)

Function taking the tangent hyperbolic value of the object.

asBool()

bool ExpressionParsing::StackElement::asBool

(

)

const

Get the internal value of the object as a boolean.

Definition at line 255 of file StackElement.cxx.

                                   {
 
      if( ! ( ( m_type == SE_INT ) || ( m_type == SE_DOUBLE ) ) ) {
         throw std::runtime_error( "asBool() only valid for non-vector types" );
      }
 
      return scalarValue< bool >();
   }

asInt()

int ExpressionParsing::StackElement::asInt

(

)

const

Get the internal value of the object as an integer.

Definition at line 246 of file StackElement.cxx.

                                 {
 
      if( m_type != SE_INT ) {
         throw std::runtime_error( "asInt() only valid for SE_INT" );
      }
 
      return scalarValue< int >();
   }

ensureCompatible()

void ExpressionParsing::StackElement::ensureCompatible ( const StackElement & other ) const

private

Definition at line 765 of file StackElement.cxx.

                                                                        {
 
      if( this->m_type != other.m_type ) {
         throw std::runtime_error( "Incompatible stack elements" );
      }
 
      return;
   }

ensureCompatibleVectors() [1/3]

template<>

void ExpressionParsing::StackElement::ensureCompatibleVectors

(

const StackElement &

other

)

const

Definition at line 776 of file StackElement.cxx.

                                                                          {
 
      if( isScalar() ) {
         return;
      }
 
      const std::size_t ourlen = size();
      if( ourlen != other.size() ) {
         throw std::runtime_error( "Incompatible vectors - different length" );
      }
   }

ensureCompatibleVectors() [2/3]

template<typename T>

void ExpressionParsing::StackElement::ensureCompatibleVectors ( const std::vector< T > & other ) const

private

ensureCompatibleVectors() [3/3]

template<typename T>

void ExpressionParsing::StackElement::ensureCompatibleVectors ( const T & other ) const

private

getType()

StackElement::ElementType ExpressionParsing::StackElement::getType

(

)

const

Get the variable type of the object.

The macro is not needed anymore:

Definition at line 226 of file StackElement.cxx.

                                                       {
 
      return m_type;
   }

isProxy()

bool ExpressionParsing::StackElement::isProxy

(

)

const

Check if the object takes its value from a StoreGate object.

Definition at line 241 of file StackElement.cxx.

                                    {
 
      return ( m_varName.length() > 0 );
   }

isScalar()

bool ExpressionParsing::StackElement::isScalar

(

)

const

Check if the object describes a scalar value.

Definition at line 231 of file StackElement.cxx.

                                     {
 
      return ( ( m_type == SE_INT ) || ( m_type == SE_DOUBLE ) );
   }

isVector()

bool ExpressionParsing::StackElement::isVector

(

)

const

Check if the object describes a vector value.

Definition at line 236 of file StackElement.cxx.

                                     {
 
      return ( ( m_type == SE_VECINT ) || ( m_type == SE_VECDOUBLE ) );
   }

makeDouble()

void ExpressionParsing::StackElement::makeDouble

(

)

Function constructing internal double values in case integer values were given to the object initially.

Definition at line 347 of file StackElement.cxx.

                                 {
 
      if( m_type == SE_INT ) {
         m_type = SE_DOUBLE;
         m_doubleVal = m_intVal;
      } else if( m_type == SE_VECINT ) {
         m_type = SE_VECDOUBLE;
         m_vecDoubleVal.clear();
         for( auto& value : m_vecIntVal ) {
            m_vecDoubleVal.push_back( static_cast< double >( value ) );
         }
      }
 
      return;
   }

makeDoubleIfNecessary() [1/5]

void ExpressionParsing::StackElement::makeDoubleIfNecessary ( const StackElement & other )

private

Definition at line 726 of file StackElement.cxx.

                                                                       {
 
      if( ( m_type == SE_INT ) && ( other.m_type == SE_DOUBLE ) ) {
         makeDouble();
      } else if( ( m_type == SE_VECINT ) && ( other.m_type == SE_VECDOUBLE ) ) {
         makeDouble();
      }
 
      return;
   }

makeDoubleIfNecessary() [2/5]

void ExpressionParsing::StackElement::makeDoubleIfNecessary ( const std::vector< double > & other )

private

Definition at line 756 of file StackElement.cxx.

                                                                        {
 
      if( m_type == SE_VECINT ) {
         makeDouble();
      }
 
      return;
   }

makeDoubleIfNecessary() [3/5]

void ExpressionParsing::StackElement::makeDoubleIfNecessary ( const std::vector< int > & other )

private

Definition at line 751 of file StackElement.cxx.

                                                                     {
 
      return;
   }

makeDoubleIfNecessary() [4/5]

void ExpressionParsing::StackElement::makeDoubleIfNecessary ( double other )

private

Definition at line 742 of file StackElement.cxx.

                                                    {
 
      if( m_type == SE_INT ) {
         makeDouble();
      }
 
      return;
   }

makeDoubleIfNecessary() [5/5]

void ExpressionParsing::StackElement::makeDoubleIfNecessary ( int other )

private

Definition at line 737 of file StackElement.cxx.

                                                 {
 
      return;
   }

makeInt()

void ExpressionParsing::StackElement::makeInt

(

)

Function constructing internal integer values in case double values were given to the object initially.

Definition at line 331 of file StackElement.cxx.

                              {
 
      if( m_type == SE_DOUBLE ) {
         m_type = SE_INT;
         m_intVal = m_doubleVal;
      } else if( m_type == SE_VECDOUBLE ) {
         m_type = SE_VECINT;
         m_vecIntVal.clear();
         for( auto& value : m_vecDoubleVal ) {
            m_vecIntVal.push_back( static_cast< int >( value ) );
         }
      }
 
      return;
   }

makeVector()

void ExpressionParsing::StackElement::makeVector

(

std::size_t

n

)

Function converting a possibly scalar value into a vector.

Definition at line 363 of file StackElement.cxx.

                                              {
 
      if( isVector() ) {
         return;
      }
 
      if( m_type == SE_INT ) {
         m_type = SE_VECINT;
         m_vecIntVal.clear();
         m_vecIntVal.resize( n, m_intVal );
      } else if( m_type == SE_DOUBLE ) {
         m_type = SE_VECDOUBLE;
         m_vecDoubleVal.clear();
         m_vecDoubleVal.resize( n, m_doubleVal );
      }
 
      return;
   }

makeVectorIfNecessary() [1/3]

void ExpressionParsing::StackElement::makeVectorIfNecessary ( const StackElement & other )

private

The macro is not needed anymore:

Definition at line 693 of file StackElement.cxx.

                                                                       {
 
      if( isVector() ) {
         return;
      }
      if( other.isVector() ) {
         makeVector( other.size() );
      }
 
      return;
   }

makeVectorIfNecessary() [2/3]

void ExpressionParsing::StackElement::makeVectorIfNecessary ( const std::vector< double > & other )

private

Definition at line 716 of file StackElement.cxx.

                                                                         {
 
      if( isVector() ) {
         return;
      }
      makeVector( other.size() );
 
      return;
   }

makeVectorIfNecessary() [3/3]

void ExpressionParsing::StackElement::makeVectorIfNecessary ( const std::vector< int > & other )

private

Definition at line 705 of file StackElement.cxx.

                                                                          {
 
      if( isVector() ) {
         return;
      }
      makeVector( other.size() );
 
      return;
   }

operator!()

StackElement ExpressionParsing::StackElement::operator!

(

)

NOT operator.

Definition at line 110 of file StackElement.cxx.

                                        {
 
      // Create a copy of the object:
      if (this->m_moved) throw std::logic_error("Content already moved");
      StackElement temp( std::move(*this) );
      this->m_moved=true;
      // ...and modify its payload appropriately:
      switch( m_type ) {
 
      case SE_INT:
         temp.m_intVal = !( temp.m_intVal );
         break;
 
      case SE_DOUBLE:
         //         temp.makeInt();
         temp.m_intVal = !( temp.m_doubleVal );
         break;
 
      case SE_VECINT:
         for( std::size_t i = 0; i < temp.m_vecIntVal.size(); ++i ) {
            temp.m_vecIntVal[ i ] = !( temp.m_vecIntVal[ i ] );
         }
         break;
 
      case SE_VECDOUBLE:
         //         temp.makeInt();
         temp.m_vecIntVal.resize(temp.m_vecDoubleVal.size());
         for( std::size_t i = 0; i < temp.m_vecDoubleVal.size(); ++i ) {
            temp.m_vecIntVal[ i ] = !( temp.m_vecDoubleVal[ i ] ); // @TODO use >0. ?
         }
         break;
 
      default:
         throw std::runtime_error( "! operator called on unknown "
                                   "variable type" );
         break;
      }
 
      // Return the negated object:
      return temp;
   }

operator*() [1/2]

template<typename T>

StackElement ExpressionParsing::StackElement::operator*

(

const T &

rhs

)

operator*() [2/2]

StackElement ExpressionParsing::StackElement::operator*

(

StackElement &

rhs

)

Operator multiplying the object by a value.

operator*=() [1/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator*=

(

const std::vector< T > &

rhs

)

Multiply the object by a vector type.

operator*=() [2/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator*=

(

const T &

rhs

)

operator*=() [3/3]

StackElement & ExpressionParsing::StackElement::operator*=

(

StackElement &

rhs

)

Multiply the object by a scalar type.

operator+() [1/2]

template<typename T>

StackElement ExpressionParsing::StackElement::operator+

(

const T &

rhs

)

operator+() [2/2]

StackElement ExpressionParsing::StackElement::operator+

(

StackElement &

rhs

)

Operator adding a value to the object.

operator+=() [1/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator+=

(

const std::vector< T > &

rhs

)

Add a vector type to the object.

operator+=() [2/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator+=

(

const T &

rhs

)

operator+=() [3/3]

StackElement & ExpressionParsing::StackElement::operator+=

(

StackElement &

rhs

)

Add a scalar type to the object.

operator-() [1/3]

StackElement ExpressionParsing::StackElement::operator-

(

)

Inverse operator.

Definition at line 152 of file StackElement.cxx.

                                        {
 
      // Create a copy of the object:
      if (this->m_moved) throw std::logic_error("Content already moved");
      StackElement temp( std::move(*this) );
      this->m_moved=true;
 
      // ...and modify its payload appropriately:
      switch( m_type ) {
 
      case SE_INT:
         temp.m_intVal = -( this->m_intVal );
         break;
 
      case SE_DOUBLE:
         temp.m_doubleVal = -( this->m_doubleVal );
         break;
 
      case SE_VECINT:
         for( std::size_t i = 0; i < temp.m_vecIntVal.size(); ++i ) {
            temp.m_vecIntVal[ i ] = -( temp.m_vecIntVal[ i ] );
         }
         break;
 
      case SE_VECDOUBLE:
         for( std::size_t i = 0; i < temp.m_vecDoubleVal.size(); ++i ) {
            temp.m_vecDoubleVal[ i ] = -( temp.m_vecDoubleVal[ i ] );
         }
         break;
 
      default:
         throw std::runtime_error( "- operator called on unknown "
                                   "variable type" );
         break;
      }
 
      // Return the inverted object:
      return temp;
   }

operator-() [2/3]

template<typename T>

StackElement ExpressionParsing::StackElement::operator-

(

const T &

rhs

)

operator-() [3/3]

StackElement ExpressionParsing::StackElement::operator-

(

StackElement &

rhs

)

Operator subtracting a value from the object.

operator-=() [1/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator-=

(

const std::vector< T > &

rhs

)

Subtract a vector type from the object.

operator-=() [2/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator-=

(

const T &

rhs

)

operator-=() [3/3]

StackElement & ExpressionParsing::StackElement::operator-=

(

StackElement &

rhs

)

Subtract a scalar type from the object.

operator/() [1/2]

template<typename T>

StackElement ExpressionParsing::StackElement::operator/

(

const T &

rhs

)

operator/() [2/2]

StackElement ExpressionParsing::StackElement::operator/

(

StackElement &

rhs

)

Operator dividing the object by a value.

operator/=() [1/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator/=

(

const std::vector< T > &

rhs

)

Divide the object by a vector type.

operator/=() [2/3]

template<typename T>

StackElement & ExpressionParsing::StackElement::operator/=

(

const T &

rhs

)

operator/=() [3/3]

StackElement & ExpressionParsing::StackElement::operator/=

(

StackElement &

rhs

)

Divide the object by a scalar type.

operator=() [1/7]

StackElement & ExpressionParsing::StackElement::operator=

(

const std::vector< double > &

rhs

)

Operator assigning a vector of doubles to the object.

Definition at line 86 of file StackElement.cxx.

                                                                         {
 
      m_type = SE_VECDOUBLE;
      m_intVal = 0;
      m_doubleVal = 0;
      m_vecIntVal.clear();
      m_vecDoubleVal = rhs;
      m_moved = false;
 
      return *this;
   }

operator=() [2/7]

StackElement & ExpressionParsing::StackElement::operator=

(

const std::vector< int > &

rhs

)

Operator assigning a vector of integers to the object.

Definition at line 64 of file StackElement.cxx.

                                                                      {
 
      m_type = SE_VECINT;
      m_intVal = 0;
      m_doubleVal = 0;
      m_vecIntVal = rhs;
      m_vecDoubleVal.clear();
      m_moved = false;
 
      return *this;
   }

operator=() [3/7]

StackElement & ExpressionParsing::StackElement::operator=

(

double

rhs

)

Operator assigning a double value to the object.

Definition at line 51 of file StackElement.cxx.

                                                     {
 
      m_type = SE_DOUBLE;
      m_intVal = 0;
      m_doubleVal = rhs;
      m_vecIntVal.clear();
      m_vecDoubleVal.clear();
      m_moved = false;
 
      return *this;
   }

operator=() [4/7]

StackElement & ExpressionParsing::StackElement::operator=

(

int

rhs

)

Operator assigning an integer value to the object.

Definition at line 39 of file StackElement.cxx.

                                                  {
 
      m_type = SE_INT;
      m_intVal = rhs;
      m_doubleVal = 0;
      m_vecIntVal.clear();
      m_vecDoubleVal.clear();
      m_moved = false;
 
      return *this;
   }

operator=() [5/7]

StackElement & ExpressionParsing::StackElement::operator=

(

StackElement &&

rhs

)

operator=() [6/7]

StackElement & ExpressionParsing::StackElement::operator=

(

std::vector< double > &&

rhs

)

Operator assigning a vector of doubles to the object.

Definition at line 98 of file StackElement.cxx.

                                                                    {
 
      m_type = SE_VECDOUBLE;
      m_intVal = 0;
      m_doubleVal = 0;
      m_vecIntVal.clear();
      m_vecDoubleVal = std::move(rhs);
      m_moved = false;
 
      return *this;
   }

operator=() [7/7]

StackElement & ExpressionParsing::StackElement::operator=

(

std::vector< int > &&

rhs

)

Operator assigning a vector of integers to the object.

Definition at line 75 of file StackElement.cxx.

                                                                 {
 
      m_type = SE_VECINT;
      m_intVal = 0;
      m_doubleVal = 0;
      m_vecIntVal = std::move(rhs);
      m_vecDoubleVal.clear();
      m_moved = false;
 
      return *this;
   }

proxyVarName()

const std::string & ExpressionParsing::StackElement::proxyVarName ( ) const

inline

Definition at line 189 of file StackElement.h.

{ return m_varName; }

scalarValue()

template<typename T>

T ExpressionParsing::StackElement::scalarValue

(

)

const

Evaluate the value of the object into the requested scalar type.

size()

size_t ExpressionParsing::StackElement::size ( ) const

private

valueFromProxy()

StackElement ExpressionParsing::StackElement::valueFromProxy

(

const EventContext &

ctx

)

const

Set the internal variables of the object based on the objects in SG.

Definition at line 382 of file StackElement.cxx.

                                                                                           {
 
      StackElement tmp;
      if( ! isProxy() ) {
         return tmp;
      }
 
      IAccessor::VariableType the_variable_type=m_variableType.load(std::memory_order_seq_cst);
      if( the_variable_type==IProxyLoader::VT_UNK) {
         auto [variable_type, accessor] = m_proxyLoader->getAccessorFromString(ctx, m_varName);
         //         if ( m_variableType != IProxyLoader::VT_UNK) {
         if (variable_type != IProxyLoader::VT_VECEMPTY) {
            // do not cache the accessor and variable type if it was an empty vector because
            // in such cases there is not enough information to decide the variable type.
            // otherwise set the accessor if still unset and set the variable type.
            // Other threads would come to the same conclusion in case the vector is not empty
            // (or empty), so which thread sets the variable type and/or accessor does not matter.
            m_accessor.setIfUnset(accessor);
            m_variableType.store(variable_type, std::memory_order_seq_cst);
         }
         // for the current event what ever getAccessorFromString returned is a good choice
         // independent of other threads which might have had more information for a final
         // decision. So, for this evaluation what ever getAccessorFromString returned will
         // be used.
         the_variable_type = variable_type;
      }
      assert((the_variable_type == IProxyLoader::VT_UNK && m_accessor == true)  );
 
      switch( the_variable_type ) {
      case IProxyLoader::VT_INT:
         tmp = m_accessor->loadInt(ctx, m_varName );
         break;
 
      case IProxyLoader::VT_DOUBLE:
         tmp = m_accessor->loadDouble(ctx, m_varName );
         break;
 
      case IProxyLoader::VT_VECINT:
         tmp = m_accessor->loadVecInt(ctx, m_varName );
         break;
 
      case IProxyLoader::VT_VECDOUBLE: {
         tmp = m_accessor->loadVec(ctx, m_varName );
         break;
      }
      case IProxyLoader::VT_VECEMPTY:
         tmp=std::vector<double>();
         break;
      case IProxyLoader::VT_UNK:
      default:
         throw std::runtime_error( "Got VT_UNK - unknown identifier: " +
                                   m_varName );
         break;
      }
 
      return tmp;
   }

vectorValue() [1/3]

template<>

std::vector< double > ExpressionParsing::StackElement::vectorValue

(

size_t

sizeIfScalar

)

Definition at line 299 of file StackElement.cxx.

                                                  {
 
      if (this->m_moved) throw std::logic_error("Content already moved");
      switch( m_type ) {
 
      case SE_VECINT: {
         std::vector<double> ret(m_vecIntVal.size());
         std::transform (m_vecIntVal.begin(), m_vecIntVal.end(), ret.begin(), [](int a) -> double { return a;});
         return ret;
         break;
      }
      case SE_VECDOUBLE:
         m_moved=true;
         return std::move(m_vecDoubleVal);
         break;
 
      case SE_INT: {
         return std::vector<double>(sizeIfScalar,static_cast< double >( m_intVal ) );
         break;
      }
      case SE_DOUBLE: {
         return std::vector<double>(sizeIfScalar, m_doubleVal );
         break;
      }
      default:
         throw std::runtime_error( "(dbl) vectorValue(): Unsupported "
                                   "StackElement" );
         break;
      }
      return std::vector<double>();
   }

vectorValue() [2/3]

template<>

std::vector< int > ExpressionParsing::StackElement::vectorValue

(

std::size_t

sizeIfScalar

)

Definition at line 266 of file StackElement.cxx.

                                                      {
 
      if (this->m_moved) throw std::logic_error("Content already moved");
      switch( m_type ) {
 
      case SE_VECINT:
         this->m_moved=true;
         return std::move(m_vecIntVal);
         break;
 
      case SE_VECDOUBLE: {
         std::vector<int> ret(m_vecDoubleVal.size());
         std::transform (m_vecDoubleVal.begin(), m_vecDoubleVal.end(), ret.begin(), [](const double  &a) -> int { return static_cast<int>(a);});
         break;
      }
      case SE_INT: {
         return std::vector<int>( sizeIfScalar, m_intVal );
         break;
      }
      case SE_DOUBLE:{
         return std::vector<int>( sizeIfScalar,static_cast< int >( m_doubleVal ) );
         break;
      }
      default:
         throw std::runtime_error( "(int) vectorValue(): Unsupported "
                                   "StackElement" );
         break;
      }
      return std::vector<int>();
   }

vectorValue() [3/3]

template<typename T>

std::vector< T > ExpressionParsing::StackElement::vectorValue

(

std::size_t

sizeIfScalar = 0

)

Evaluate the value of the object into the requested vector type.

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & os, const StackElement & el )

friend

Declare the print operator as a friend of the class.

Definition at line 788 of file StackElement.cxx.

                                                      {
 
      switch( el.m_type ) {
 
      case StackElement::SE_INT:
         os << "(int)" << el.m_intVal;
         break;
 
      case StackElement::SE_DOUBLE:
         os << "(double)" << el.m_doubleVal;
         break;
 
      case StackElement::SE_VECINT:
         os << "(vec<int>)" << el.m_vecIntVal;
         break;
 
      case StackElement::SE_VECDOUBLE:
         os << "(vec<double>)" << el.m_vecDoubleVal;
         break;
 
      case StackElement::SE_UNK:
         os << "SE_UNK";
         break;
 
      default:
         break;
      }
 
      return os;
   }

Member Data Documentation

ATLAS_THREAD_SAFE

PointerCache<IAccessor, std::memory_order_seq_cst> m_accessor ExpressionParsing::StackElement::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 326 of file StackElement.h.

m_doubleVal

double ExpressionParsing::StackElement::m_doubleVal = 0.

private

The value of the object represented as a double.

Definition at line 314 of file StackElement.h.

m_intVal

int ExpressionParsing::StackElement::m_intVal = 0

private

The value of the object represented as an integer.

Definition at line 312 of file StackElement.h.

m_moved

std::atomic<bool> ExpressionParsing::StackElement::m_moved = false

mutableprivate

Internal flag showing whether the type of the variable was already determined.

Definition at line 329 of file StackElement.h.

m_proxyLoader

IProxyLoader* ExpressionParsing::StackElement::m_proxyLoader = nullptr

private

Loader for the described variable.

Definition at line 323 of file StackElement.h.

m_type

ElementType ExpressionParsing::StackElement::m_type = SE_UNK

private

The type of the variable held by the object.

Definition at line 309 of file StackElement.h.

m_variableType

std::atomic<IAccessor::VariableType> ExpressionParsing::StackElement::m_variableType = IProxyLoader::VT_UNK

mutableprivate

Type of the variable provided by the proxy loader.

Definition at line 325 of file StackElement.h.

m_varName

std::string ExpressionParsing::StackElement::m_varName

private

The name/definition of the variable.

Definition at line 321 of file StackElement.h.

m_vecDoubleVal

std::vector< double > ExpressionParsing::StackElement::m_vecDoubleVal

private

The value of the object represented as a vector of doubles.

Definition at line 318 of file StackElement.h.

m_vecIntVal

std::vector< int > ExpressionParsing::StackElement::m_vecIntVal

private

The value of the object represented as a vector of integers.

Definition at line 316 of file StackElement.h.

---

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

• StackElement.h
• StackElement.cxx