find.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_FIND_H
#define MCRL2_LPS_FIND_H
 
#include "mcrl2/lps/add_binding.h"
#include "mcrl2/lps/traverser.h"
#include "mcrl2/process/find.h"
 
namespace mcrl2
{
 
namespace lps
{
 
//--- start generated lps find code ---//
template <typename T, typename OutputIterator>
void find_all_variables(const T& x, OutputIterator o)
{
  data::detail::make_find_all_variables_traverser<lps::variable_traverser>(o).apply(x);
}
 
template <typename T>
std::set<data::variable> find_all_variables(const T& x)
{
  std::set<data::variable> result;
  lps::find_all_variables(x, std::inserter(result, result.end()));
  return result;
}
 
template <typename T, typename OutputIterator>
void find_free_variables(const T& x, OutputIterator o)
{
  data::detail::make_find_free_variables_traverser<lps::data_expression_traverser, lps::add_data_variable_traverser_binding>(o).apply(x);
}
 
template <typename T, typename OutputIterator, typename VariableContainer>
void find_free_variables_with_bound(const T& x, OutputIterator o, const VariableContainer& bound)
{
  data::detail::make_find_free_variables_traverser<lps::data_expression_traverser, lps::add_data_variable_traverser_binding>(o, bound).apply(x);
}
 
template <typename T>
std::set<data::variable> find_free_variables(const T& x)
{
  std::set<data::variable> result;
  lps::find_free_variables(x, std::inserter(result, result.end()));
  return result;
}
 
template <typename T, typename VariableContainer>
std::set<data::variable> find_free_variables_with_bound(const T& x, VariableContainer const& bound)
{
  std::set<data::variable> result;
  lps::find_free_variables_with_bound(x, std::inserter(result, result.end()), bound);
  return result;
}
 
template <typename T, typename OutputIterator>
void find_identifiers(const T& x, OutputIterator o)
{
  data::detail::make_find_identifiers_traverser<lps::identifier_string_traverser>(o).apply(x);
}
 
template <typename T>
std::set<core::identifier_string> find_identifiers(const T& x)
{
  std::set<core::identifier_string> result;
  lps::find_identifiers(x, std::inserter(result, result.end()));
  return result;
}
 
template <typename T, typename OutputIterator>
void find_sort_expressions(const T& x, OutputIterator o)
{
  data::detail::make_find_sort_expressions_traverser<lps::sort_expression_traverser>(o).apply(x);
}
 
template <typename T>
std::set<data::sort_expression> find_sort_expressions(const T& x)
{
  std::set<data::sort_expression> result;
  lps::find_sort_expressions(x, std::inserter(result, result.end()));
  return result;
}
 
template <typename T, typename OutputIterator>
void find_function_symbols(const T& x, OutputIterator o)
{
  data::detail::make_find_function_symbols_traverser<lps::data_expression_traverser>(o).apply(x);
}
 
template <typename T>
std::set<data::function_symbol> find_function_symbols(const T& x)
{
  std::set<data::function_symbol> result;
  lps::find_function_symbols(x, std::inserter(result, result.end()));
  return result;
}
//--- end generated lps find code ---//
 
template <typename T>
bool search_free_variable(const T& x, const data::variable& v)
{
  data::detail::search_free_variable_traverser<lps::data_expression_traverser, lps::add_data_variable_traverser_binding> f(v);
  f.apply(x);
  return f.found;
}
 
template <typename T, typename OutputIterator>
void find_action_labels(const T& x, OutputIterator o)
{
  process::detail::make_find_action_labels_traverser<lps::action_label_traverser>(o).apply(x);
}
 
template <typename T>
std::set<process::action_label> find_action_labels(const T& x)
{
  std::set<process::action_label> result;
  lps::find_action_labels(x, std::inserter(result, result.end()));
  return result;
}
 
} // namespace lps
 
} // namespace mcrl2
 
#endif