action_summand.h

Go to the documentation of this file.

// Author(s): Wieger Wesselink
// Copyright: see the accompanying file COPYING or copy at
// https://github.com/mCRL2org/mCRL2/blob/master/COPYING
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MCRL2_LPS_ACTION_SUMMAND_H
#define MCRL2_LPS_ACTION_SUMMAND_H
 
#include "mcrl2/lps/multi_action.h"
#include "mcrl2/lps/stochastic_distribution.h"
#include "mcrl2/lps/summand.h"
 
namespace mcrl2 {
 
namespace lps {
 
class action_summand: public summand_base
{
  protected:
    typedef summand_base super;
 
    lps::multi_action m_multi_action;
 
    data::assignment_list m_assignments;
 
  public:
    action_summand()
    {}
 
    action_summand(const data::variable_list& summation_variables, const data::data_expression& condition, const lps::multi_action& action, const data::assignment_list& assignments)
      : summand_base(summation_variables, condition),
        m_multi_action(action),
        m_assignments(assignments)
    {}
 
    action_summand(const action_summand&) noexcept = default;
    action_summand(action_summand&&) noexcept = default;
    action_summand& operator=(const action_summand&) noexcept = default;
    action_summand& operator=(action_summand&&) noexcept = default;
 
    const lps::multi_action& multi_action() const
    {
      return m_multi_action;
    }
 
    lps::multi_action& multi_action()
    {
      return m_multi_action;
    }
 
    const data::assignment_list& assignments() const
    {
      return m_assignments;
    }
 
    data::assignment_list& assignments()
    {
      return m_assignments;
    }
 
    // TODO: check if this is correct (where is the documentation of the internal format?)
    bool is_tau() const
    {
      return multi_action().actions().empty();
    }
 
    bool has_time() const
    {
      return m_multi_action.has_time();
    }
 
    data::data_expression_list next_state(const data::variable_list& process_parameters) const;
 
    void swap(action_summand& other)
    {
      summand_base::swap(other);
      using std::swap;
      swap(m_multi_action, other.m_multi_action);
      swap(m_assignments, other.m_assignments);
    }
};
 
//--- start generated class action_summand ---//
typedef atermpp::term_list<action_summand> action_summand_list;
 
typedef std::vector<action_summand>    action_summand_vector;
 
// prototype declaration
std::string pp(const action_summand& x);
 
inline
std::ostream& operator<<(std::ostream& out, const action_summand& x)
{
  return out << lps::pp(x);
}
 
inline void swap(action_summand& t1, action_summand& t2)
{
  t1.swap(t2);
}
//--- end generated class action_summand ---//
 
inline
bool operator<(const action_summand& x, const action_summand& y)
{
  if (x.summation_variables() != y.summation_variables())
  {
    return x.summation_variables() < y.summation_variables();
  }
  if (x.condition() != y.condition())
  {
    return x.condition() < y.condition();
  }
  if (x.multi_action() != y.multi_action())
  {
    return x.multi_action() < y.multi_action();
  }
  return x.assignments() < y.assignments();
}
 
inline
bool operator==(const action_summand& x, const action_summand& y)
{
  return x.summation_variables() == y.summation_variables() &&
         x.condition() == y.condition() &&
         x.multi_action() == y.multi_action() &&
         x.assignments() == y.assignments();
}
 
inline
atermpp::aterm action_summand_to_aterm(const action_summand& s)
{
  atermpp::aterm result = atermpp::aterm(core::detail::function_symbol_LinearProcessSummand(),
                       s.summation_variables(),
                       s.condition(),
                       s.multi_action(),
                       s.multi_action().time(),
                       s.assignments(),
                       lps::stochastic_distribution()
                     );
  return result;
}
 
} // namespace lps
 
} // namespace mcrl2
 
#endif // MCRL2_LPS_ACTION_SUMMAND_H