Validators.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include "../../EventSlot.h"
#include "../PrecedenceRulesGraph.h"
#include "IGraphVisitor.h"
 
#include <algorithm>
#include <map>
#include <set>
#include <sstream>
#include <unordered_map>
#include <vector>
 
namespace concurrency {
 
  //--------------------------------------------------------------------------
  class NodePropertiesValidator : public IGraphVisitor {
  public:
    using IGraphVisitor::visit;
    using IGraphVisitor::visitEnter;
 
    bool visitEnter( AlgorithmNode& ) const override { return false; }
    bool visitEnter( DataNode& ) const override { return false; }
    bool visitEnter( ConditionNode& ) const override { return false; }
 
    bool visit( DecisionNode& ) override;
 
    std::string reply() const { return m_status.str(); }
    bool        passed() const { return !m_foundViolations; }
    void        reset() override {
      m_foundViolations = false;
      m_status.clear();
    }
 
  private:
    std::ostringstream m_status{ "  No 'Concurrent'/'Prompt' contradictions found" };
    bool               m_foundViolations{ false };
  };
 
  //--------------------------------------------------------------------------
  class ActiveLineageScout : public IGraphVisitor {
  public:
    ActiveLineageScout( const EventSlot* slot, const ControlFlowNode& node )
        : m_slot( slot ), m_startNode( node ), m_previousNodeName( node.name() ) {}
 
    using IGraphVisitor::visit;
    using IGraphVisitor::visitEnter;
 
    bool visitEnter( AlgorithmNode& ) const override { return false; }
    bool visitEnter( DataNode& ) const override { return false; }
    bool visitEnter( ConditionNode& ) const override { return false; }
 
    bool visit( DecisionNode& ) override;
 
    void reset() override {
      m_active           = true;
      m_previousNodeName = m_startNode.name();
    }
 
    virtual bool reply() const { return m_active; }
 
    virtual void visitParents( DecisionNode& );
 
  protected:
    const EventSlot*       m_slot;
    const ControlFlowNode& m_startNode;
    bool                   m_active{ true };
    std::string            m_previousNodeName;
  };
 
  //--------------------------------------------------------------------------
  class SubSlotScout final : public ActiveLineageScout {
  public:
    SubSlotScout( const EventSlot* slot, const ControlFlowNode& node )
        : ActiveLineageScout( slot, node ), m_foundEntryPoint( slot->parentSlot == nullptr ) {}
 
    void reset() override {
      m_active = true;
 
      // Only look for an entry point if we're in a sub-slot
      m_foundEntryPoint  = ( m_slot->parentSlot == nullptr );
      m_previousNodeName = m_startNode.name();
    }
 
    bool reply() const override { return m_active && m_foundEntryPoint; }
 
    void visitParents( DecisionNode& ) override;
 
  private:
    bool m_foundEntryPoint{ true };
  };
 
  //--------------------------------------------------------------------------
  class ConditionalLineageFinder : public IGraphVisitor {
  public:
    using IGraphVisitor::visit;
    using IGraphVisitor::visitEnter;
 
    bool visitEnter( DataNode& ) const override { return false; }
    bool visitEnter( ConditionNode& ) const override { return false; }
 
    bool visit( DecisionNode& ) override;
    bool visit( AlgorithmNode& ) override;
 
    bool positive() const { return m_positive; }
    bool negative() const { return m_negative; }
 
    void reset() override {
      m_positive = false;
      m_negative = false;
    }
 
  private:
    bool m_positive{ false };
    bool m_negative{ false };
  };
 
  //--------------------------------------------------------------------------
  class ProductionAmbiguityFinder : public IGraphVisitor {
  public:
    using IGraphVisitor::visit;
    using IGraphVisitor::visitEnter;
 
    bool visitEnter( AlgorithmNode& ) const override { return false; }
    bool visitEnter( DecisionNode& ) const override { return false; }
 
    bool visit( DataNode& ) override;
    bool visit( ConditionNode& ) override;
 
    std::string reply() const;
    bool        passed() const {
      return std::all_of( m_unconditionalProducers.begin(), m_unconditionalProducers.end(),
                                 []( const auto& pr ) { return pr.second.size() == 1; } );
    }
    void reset() override {
      m_foundViolations = false;
      m_conditionalProducers.clear();
      m_unconditionalProducers.clear();
    }
 
  private:
    bool m_foundViolations{ false };
 
    using visitor_book =
        std::map<DataNode*, std::set<AlgorithmNode*, CompareNodes<AlgorithmNode*>>, CompareNodes<DataNode*>>;
    visitor_book m_conditionalProducers;
    visitor_book m_unconditionalProducers;
  };

  class TarjanSCCFinder : public IGraphVisitor {
  public:
    using IGraphVisitor::visit;
    using IGraphVisitor::visitEnter;
 
    bool visitEnter( ConditionNode& ) const override { return false; }
    bool visitEnter( DecisionNode& ) const override { return false; }
    bool visitEnter( AlgorithmNode& node ) const override {
      // check if the node was already visited
      return m_lowlinks.find( &node ) != m_lowlinks.end() ? false : true;
    }
 
    bool visit( AlgorithmNode& nodeAt ) override;
 
    bool passed() const {
      return m_scc.empty() ||
             !std::any_of( m_scc.begin(), m_scc.end(), []( const auto& pr ) { return pr.second.size() > 1; } );
    }
 
    std::string reply();
 
    void reset() override {
      m_nodes_count = 0;
      m_stack.clear();
      m_lowlinks.clear();
      m_scc.clear();
      m_status = std::ostringstream{ "  No strongly connected components found in DF realm" };
    }
 
  private:
    bool on_stack( const AlgorithmNode& node ) const {
      return std::find( m_stack.begin(), m_stack.end(), &node ) != m_stack.end() ? true : false;
    }
 
    unsigned int m_nodes_count{ 0 };
 
    std::unordered_map<AlgorithmNode*, std::pair<unsigned int, unsigned int>> m_lowlinks;
    std::map<unsigned int, std::vector<AlgorithmNode*>>                       m_scc;
    std::vector<AlgorithmNode*>                                               m_stack;
 
    std::ostringstream m_status{ "  No strongly connected components found in DF realm" };
  };
 
} // namespace concurrency