specification.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_SPECIFICATION_H
#define MCRL2_LPS_SPECIFICATION_H
 
#include "mcrl2/data/data_io.h"
#include "mcrl2/data/detail/io.h"
#include "mcrl2/lps/process_initializer.h"
#include "mcrl2/lps/linear_process.h"
 
#include <cerrno>
 
namespace mcrl2
{
 
namespace lps
{
 
// prototype definitions
template <typename Object> bool check_well_typedness(const Object& o);
template <typename LinearProcess, typename InitialProcessExpression> class specification_base;
template <typename LinearProcess, typename InitialProcessExpression> atermpp::aterm specification_to_aterm(const specification_base<LinearProcess, InitialProcessExpression>& spec);
class specification;
void complete_data_specification(specification& spec);
 
// template function overloads
bool check_well_typedness(const specification& x);
void normalize_sorts(lps::specification& x, const data::sort_specification& sortspec);
 
inline
bool is_specification(const atermpp::aterm& x)
{
  return x.function() == core::detail::function_symbols::LinProcSpec;
}
 
template <typename LinearProcess, typename InitialProcessExpression>
class specification_base
{
  protected:
    data::data_specification m_data;
 
    process::action_label_list m_action_labels;
 
    std::set<data::variable> m_global_variables;
 
    LinearProcess m_process;
 
    InitialProcessExpression m_initial_process;
 
  public:
    typedef LinearProcess process_type;
 
    typedef InitialProcessExpression initial_process_type;
 
    specification_base()
    { }
 
    specification_base(const data::data_specification& data,
                       const process::action_label_list& action_labels,
                       const std::set<data::variable>& global_variables,
                       const LinearProcess& lps,
                       const InitialProcessExpression& initial_process)
       :
      m_data(data),
      m_action_labels(action_labels),
      m_global_variables(global_variables),
      m_process(lps),
      m_initial_process(initial_process)
    {
      assert(lps.process_parameters().size()==initial_process.expressions().size());
    }
 
    const LinearProcess& process() const
    {
      return m_process;
    }
 
    LinearProcess& process()
    {
      return m_process;
    }
 
    const data::data_specification& data() const
    {
      return m_data;
    }
 
    data::data_specification& data()
    {
      return m_data;
    }
 
    const process::action_label_list& action_labels() const
    {
      return m_action_labels;
    }
 
    process::action_label_list& action_labels()
    {
      return m_action_labels;
    }
 
    const std::set<data::variable>& global_variables() const
    {
      return m_global_variables;
    }
 
    std::set<data::variable>& global_variables()
    {
      return m_global_variables;
    }
 
    const InitialProcessExpression& initial_process() const
    {
      return m_initial_process;
    }
 
    InitialProcessExpression& initial_process()
    {
      return m_initial_process;
    }
};
 
class specification: public specification_base<linear_process, process_initializer>
{
  protected:
    typedef specification_base<linear_process, process_initializer> super;
 
  public:
    specification() = default;
 
    specification(const data::data_specification& data,
                  const process::action_label_list& action_labels,
                  const std::set<data::variable>& global_variables,
                  const linear_process& lps,
                  const process_initializer& initial_process)
      : super(data, action_labels, global_variables, lps, initial_process)
    {
      complete_data_specification(*this);
    }
};
 
//--- start generated class specification ---//
// prototype declaration
std::string pp(const specification& x);
 
inline
std::ostream& operator<<(std::ostream& out, const specification& x)
{
  return out << lps::pp(x);
}
//--- end generated class specification ---//
 
std::string pp_with_summand_numbers(const specification& x);
 
// template function overloads
std::set<data::sort_expression> find_sort_expressions(const lps::specification& x);
std::set<data::variable> find_all_variables(const lps::specification& x);
std::set<data::variable> find_free_variables(const lps::specification& x);
std::set<data::function_symbol> find_function_symbols(const lps::specification& x);
std::set<core::identifier_string> find_identifiers(const lps::specification& x);
std::set<process::action_label> find_action_labels(const lps::specification& x);
 
template <typename LinearProcess, typename InitialProcessExpression>
atermpp::aterm specification_to_aterm(const specification_base<LinearProcess, InitialProcessExpression>& spec)
{
  return atermpp::aterm(core::detail::function_symbol_LinProcSpec(),
           data::detail::data_specification_to_aterm(spec.data()),
           atermpp::aterm(core::detail::function_symbol_ActSpec(), spec.action_labels()),
           atermpp::aterm(core::detail::function_symbol_GlobVarSpec(), data::variable_list(spec.global_variables().begin(),spec.global_variables().end())),
           linear_process_to_aterm(spec.process()),
           spec.initial_process()
         );
}
 
inline
bool operator==(const specification& spec1, const specification& spec2)
{
  return specification_to_aterm(spec1) == specification_to_aterm(spec2);
}
 
inline
bool operator!=(const specification& spec1, const specification& spec2)
{
  return !(spec1 == spec2);
}
 
inline
void complete_data_specification(specification& spec)
{
  std::set<data::sort_expression> s = lps::find_sort_expressions(spec);
  spec.data().add_context_sorts(s);
}
 
} // namespace lps
 
} // namespace mcrl2
 
#endif // MCRL2_LPS_SPECIFICATION_H