| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Created on: 11 déc. 2013 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef TRACEFILTER_H_ |
| #define TRACEFILTER_H_ |
| |
| #include <collection/List.h> |
| |
| #include <fml/expression/AvmCode.h> |
| |
| #include <fml/operator/OperatorLib.h> |
| |
| #include <fml/trace/TracePoint.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| class BF; |
| |
| class EvaluationEnvironment; |
| class ExecutionConfiguration; |
| class ExecutableSystem; |
| |
| |
| class InstanceOfData; |
| |
| class TraceFilter |
| { |
| |
| public: |
| /** |
| * ATTRIBUTE |
| */ |
| AvmCode mainTracePointFiter; |
| |
| ListOfTracePoint listOfVariableTracePoint; |
| |
| InstanceOfData * objectDeltaTime; |
| |
| protected: |
| |
| bool mConditionFlag; |
| bool mDecisionFlag; |
| |
| bool mPathConditionFlag; |
| bool mPathTimedConditionFlag; |
| |
| bool mPathConditionLeafNodeFlag; |
| bool mPathTimedConditionLeafNodeFlag; |
| |
| bool mNodeConditionFlag; |
| bool mNodeTimedConditionFlag; |
| |
| bool mNodeConditionLeafNodeFlag; |
| bool mNodeTimedConditionLeafNodeFlag; |
| |
| bool mTimeFilterFlag; |
| bool mAssignFilterFlag; |
| bool mNewfreshFilterFlag; |
| |
| bool mInputEnvFilterFlag; |
| bool mInputRdvFilterFlag; |
| |
| bool mInputExternalFilterFlag; |
| bool mInputInternalFilterFlag; |
| bool mInputFilterFlag; |
| |
| bool mOutputEnvFilterFlag; |
| bool mOutputRdvFilterFlag; |
| |
| bool mOutputExternalFilterFlag; |
| bool mOutputInternalFilterFlag; |
| bool mOutputFilterFlag; |
| |
| bool mMachineFilterFlag; |
| bool mStateFilterFlag; |
| bool mStatemachineFilterFlag; |
| bool mTransitionFilterFlag; |
| bool mRoutineFilterFlag; |
| |
| bool mComExternalFilterFlag; |
| bool mComInternalFilterFlag; |
| bool mComFilterFlag; |
| |
| bool mIOTraceFilterFlag; |
| bool mRunnableFilterFlag; |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| TraceFilter() |
| : mainTracePointFiter( ), |
| listOfVariableTracePoint( ), |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Computing Variables |
| objectDeltaTime( NULL ), |
| |
| mConditionFlag( false ), |
| mDecisionFlag( false ), |
| |
| mPathConditionFlag( false ), |
| mPathTimedConditionFlag( false ), |
| |
| mPathConditionLeafNodeFlag( false ), |
| mPathTimedConditionLeafNodeFlag( false ), |
| |
| mNodeConditionFlag( false ), |
| mNodeTimedConditionFlag( false ), |
| |
| mNodeConditionLeafNodeFlag( false ), |
| mNodeTimedConditionLeafNodeFlag( false ), |
| |
| mTimeFilterFlag( false ), |
| mAssignFilterFlag( false ), |
| mNewfreshFilterFlag( false ), |
| |
| mInputEnvFilterFlag( false ), |
| mInputRdvFilterFlag( false ), |
| |
| mInputExternalFilterFlag( false ), |
| mInputInternalFilterFlag( false ), |
| mInputFilterFlag( false ), |
| |
| mOutputEnvFilterFlag( false ), |
| mOutputRdvFilterFlag( false ), |
| |
| mOutputExternalFilterFlag( false ), |
| mOutputInternalFilterFlag( false ), |
| mOutputFilterFlag( false ), |
| |
| mMachineFilterFlag( false ), |
| mStateFilterFlag( false ), |
| mStatemachineFilterFlag( false ), |
| mTransitionFilterFlag( false ), |
| mRoutineFilterFlag( false ), |
| |
| mComExternalFilterFlag( false ), |
| mComInternalFilterFlag( false ), |
| mComFilterFlag( false ), |
| |
| mIOTraceFilterFlag( false ), |
| mRunnableFilterFlag( false ) |
| { |
| //!! NOTHING |
| } |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~TraceFilter() |
| { |
| //!! NOTHING |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // CONFIGURE API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool configure(EvaluationEnvironment & ENV, |
| WObject * wfParameterObject, WObject * wfTraceObject); |
| |
| bool configure(EvaluationEnvironment & ENV, WObject * wfParameterObject, |
| const std::string & aWSequenceNameID, |
| const std::string & aWSequenceElseNameID); |
| |
| inline bool configure( |
| EvaluationEnvironment & ENV, WObject * wfParameterObject) |
| { |
| return( configure(ENV, wfParameterObject, "trace", "TRACE") ); |
| } |
| |
| |
| inline bool contains(ENUM_TRACE_POINT::TRACE_NATURE nature, AVM_OPCODE op) |
| { |
| return( mainTracePointFiter.empty() |
| || ( (op == AVM_OPCODE_NULL) |
| && (nature == ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE) ) |
| || contains(nature, op, & mainTracePointFiter) ); |
| } |
| |
| inline bool contains(ENUM_TRACE_POINT::TRACE_NATURE nature) |
| { |
| return( mainTracePointFiter.empty() || |
| (nature == ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE) || |
| contains(nature, AVM_OPCODE_NULL, & mainTracePointFiter) ); |
| } |
| |
| inline bool contains(AVM_OPCODE op) |
| { |
| return( contains(ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE, op) ); |
| } |
| |
| inline bool containsOr(AVM_OPCODE op1, AVM_OPCODE op2) |
| { |
| return( contains(ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE, op1) || |
| contains(ENUM_TRACE_POINT::TRACE_UNDEFINED_NATURE, op2) ); |
| } |
| |
| inline bool containsCom() |
| { |
| return( contains(ENUM_TRACE_POINT::TRACE_COM_NATURE ) || |
| contains(ENUM_TRACE_POINT::TRACE_CHANNEL_NATURE) || |
| contains(ENUM_TRACE_POINT::TRACE_MESSAGE_NATURE) || |
| contains(ENUM_TRACE_POINT::TRACE_PORT_NATURE ) || |
| contains(ENUM_TRACE_POINT::TRACE_SIGNAL_NATURE ) ); |
| } |
| |
| bool contains(ENUM_TRACE_POINT::TRACE_NATURE nature, |
| AVM_OPCODE op, AvmCode * aCode) const; |
| |
| bool contains(ENUM_TRACE_POINT::TRACE_NATURE nature, |
| AVM_OPCODE op, const BF & arg) const; |
| |
| |
| /** |
| * Update |
| * Filter Point Flags |
| */ |
| // void updateFilterFlags(); |
| |
| |
| inline bool hasConditionPoint() const |
| { |
| return( mConditionFlag ); |
| } |
| |
| inline bool hasDecisionPoint() const |
| { |
| return( mDecisionFlag ); |
| } |
| |
| |
| inline bool hasPathConditionPoint() const |
| { |
| return( mPathConditionFlag ); |
| } |
| |
| inline bool hasPathTimedConditionPoint() const |
| { |
| return( mPathTimedConditionFlag ); |
| } |
| |
| |
| inline bool hasPathConditionLeafNodePoint() const |
| { |
| return( mPathConditionLeafNodeFlag ); |
| } |
| |
| inline bool hasPathTimedConditionLeafNodePoint() const |
| { |
| return( mPathTimedConditionLeafNodeFlag ); |
| } |
| |
| |
| inline bool hasPathConditionTracePoint() const |
| { |
| return( mPathConditionFlag || mPathConditionLeafNodeFlag ); |
| } |
| |
| inline bool hasPathTimedConditionTracePoint() const |
| { |
| return( mPathTimedConditionFlag || mPathTimedConditionLeafNodeFlag ); |
| } |
| |
| |
| inline bool hasNodeConditionPoint() const |
| { |
| return( mNodeConditionFlag ); |
| } |
| |
| inline bool hasNodeTimedConditionPoint() const |
| { |
| return( mNodeTimedConditionFlag ); |
| } |
| |
| |
| inline bool hasTimePoint() const |
| { |
| return( mTimeFilterFlag ); |
| } |
| |
| inline bool hasAssignPoint() const |
| { |
| return( mAssignFilterFlag ); |
| } |
| |
| inline bool hasNewfreshPoint() const |
| { |
| return( mNewfreshFilterFlag ); |
| } |
| |
| |
| inline bool hasInputEnvPoint() const |
| { |
| return( mInputEnvFilterFlag ); |
| } |
| |
| inline bool hasInputRdvPoint() const |
| { |
| return( mInputRdvFilterFlag ); |
| } |
| |
| inline bool hasInputPoint() const |
| { |
| return( mInputFilterFlag ); |
| } |
| |
| |
| inline bool hasOutputEnvPoint() const |
| { |
| return( mOutputEnvFilterFlag ); |
| } |
| |
| inline bool hasOutputRdvPoint() const |
| { |
| return( mOutputRdvFilterFlag ); |
| } |
| |
| inline bool hasOutputPoint() const |
| { |
| return( mOutputFilterFlag ); |
| } |
| |
| |
| inline bool hasMachinePoint() const |
| { |
| return( mMachineFilterFlag ); |
| } |
| |
| inline bool hasStatePoint() const |
| { |
| return( mStateFilterFlag ); |
| } |
| |
| inline bool hasStatemachinePoint() const |
| { |
| return( mStatemachineFilterFlag ); |
| } |
| |
| inline bool hasTransitionPoint() const |
| { |
| return( mTransitionFilterFlag ); |
| } |
| |
| inline bool hasRoutinePoint() const |
| { |
| return( mRoutineFilterFlag ); |
| } |
| |
| |
| inline bool hasComPoint() const |
| { |
| return( mComFilterFlag ); |
| } |
| |
| inline bool hasIOTracePoint() const |
| { |
| return( mIOTraceFilterFlag ); |
| } |
| |
| inline bool hasRunnablePoint() const |
| { |
| return( mRunnableFilterFlag ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API: check if a generic pointer Element pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| template< class T > bool pass(T * anElement) |
| { |
| if( anElement == NULL ) |
| { |
| return( false ); |
| } |
| |
| |
| AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRACE ) |
| AVM_OS_TRACE << std::endl; |
| AVM_OS_TRACE << "candidat :> " << anElement->str() << std::endl; |
| AVM_OS_TRACE << "filterTP :>" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRACE ) |
| |
| return( pass(& mainTracePointFiter, anElement) ); |
| } |
| |
| template< class T > bool pass(const BF & filterArg, T * anElement) |
| { |
| if( filterArg.is< TracePoint >() ) |
| { |
| return( pass(filterArg.to_ptr< TracePoint >(), anElement) ); |
| } |
| |
| else if( filterArg.is< AvmCode >() ) |
| { |
| return( pass(filterArg.to_ptr< AvmCode >(), anElement) ); |
| } |
| return( false ); |
| } |
| |
| template< class T > bool pass(AvmCode * filterCode, T * anElement) |
| { |
| switch( filterCode->getAvmOpCode() ) |
| { |
| case AVM_OPCODE_AND: |
| { |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( not pass((*itFilter), anElement) ) |
| { |
| return( false ); |
| } |
| } |
| |
| return( true ); |
| } |
| |
| case AVM_OPCODE_OR: |
| { |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( pass((*itFilter), anElement) ) |
| { |
| return( true ); |
| } |
| } |
| |
| return( false ); |
| } |
| |
| case AVM_OPCODE_XOR: |
| { |
| avm_size_t passCount = 0; |
| |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( pass((*itFilter), anElement) ) |
| { |
| if( ++passCount > 1 ) |
| { |
| return( false ); |
| } |
| } |
| } |
| |
| return( passCount == 1 ); |
| } |
| |
| case AVM_OPCODE_NOT: |
| { |
| return( not pass(filterCode->first(), anElement) ); |
| } |
| |
| default: |
| { |
| return( false ); |
| } |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API: check if a generic reference Element pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| template< class T > bool pass(T & anElement) |
| { |
| if( anElement == NULL ) |
| { |
| return( false ); |
| } |
| |
| |
| AVM_IF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRACE ) |
| AVM_OS_TRACE << std::endl; |
| AVM_OS_TRACE << "candidat :> " << anElement.str() << std::endl; |
| AVM_OS_TRACE << "filterTP :>" << std::endl; |
| AVM_ENDIF_DEBUG_LEVEL_FLAG2( HIGH , PROCESSOR , TRACE ) |
| |
| return( pass(& mainTracePointFiter, anElement) ); |
| } |
| |
| template< class T > bool pass(const BF & filterArg, T & anElement) |
| { |
| if( filterArg.is< TracePoint >() ) |
| { |
| return( pass(filterArg.to_ptr< TracePoint >(), anElement) ); |
| } |
| |
| else if( filterArg.is< AvmCode >() ) |
| { |
| return( pass(filterArg.to_ptr< AvmCode >(), anElement) ); |
| } |
| return( false ); |
| } |
| |
| template< class T > bool pass(AvmCode * filterCode, T & anElement) |
| { |
| switch( filterCode->getAvmOpCode() ) |
| { |
| case AVM_OPCODE_AND: |
| { |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( not pass((*itFilter), anElement) ) |
| { |
| return( false ); |
| } |
| } |
| |
| return( true ); |
| } |
| |
| case AVM_OPCODE_OR: |
| { |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( pass((*itFilter), anElement) ) |
| { |
| return( true ); |
| } |
| } |
| |
| return( false ); |
| } |
| |
| case AVM_OPCODE_XOR: |
| { |
| avm_size_t passCount = 0; |
| |
| AvmCode::const_iterator itFilter = filterCode->begin(); |
| AvmCode::const_iterator endIt = filterCode->end(); |
| for( ; itFilter != endIt ; ++itFilter ) |
| { |
| if( pass((*itFilter), anElement) ) |
| { |
| if( ++passCount > 1 ) |
| { |
| return( false ); |
| } |
| } |
| } |
| |
| return( passCount == 1 ); |
| } |
| |
| case AVM_OPCODE_NOT: |
| { |
| return( not pass(filterCode->first(), anElement) ); |
| } |
| |
| default: |
| { |
| return( false ); |
| } |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if TRACE POINT pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(TracePoint * filterTP, TracePoint * aTP); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if VARIABLE pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(const RuntimeID & aRID, InstanceOfData * aVariable); |
| |
| bool pass(TracePoint * filterTP, |
| const RuntimeID & aRID, InstanceOfData * aVariable); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if Execution Trace |
| // a.k.a. ExecutionConfiguration pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(TracePoint * filterTP, ExecutionConfiguration * anExecConfTP); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if a Compiled Element pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(TracePoint * filterTP, |
| const RuntimeID & aRID, BaseCompiledForm * anElement); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if a Runtime Machine ID pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(TracePoint * filterTP, const RuntimeID & aRID); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // FILTERING API : check if AVM CODE pass |
| //////////////////////////////////////////////////////////////////////////// |
| |
| bool pass(TracePoint * filterTP, AvmCode * aCodeTP); |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // SERIALIZATION API |
| //////////////////////////////////////////////////////////////////////////// |
| |
| virtual void toStream(OutStream & os) const; |
| |
| }; |
| |
| |
| |
| } /* namespace sep */ |
| |
| #endif /* TRACEFILTER_H_ */ |
