expression.hpp

Go to the documentation of this file.

#pragma once
#include <ossia/editor/expression/expression_atom.hpp>
#include <ossia/editor/expression/expression_bool.hpp>
#include <ossia/editor/expression/expression_composition.hpp>
#include <ossia/editor/expression/expression_fwd.hpp>
#include <ossia/editor/expression/expression_generic.hpp>
#include <ossia/editor/expression/expression_not.hpp>
#include <ossia/editor/expression/expression_pulse.hpp>
 
namespace ossia::expressions
{
OSSIA_EXPORT bool evaluate(const expression_base& e);
inline bool evaluate(const expression_ptr& e)
{
  return evaluate(*e);
}
 
OSSIA_EXPORT void update(const expression_base& e);
inline void update(const expression_ptr& e)
{
  update(*e);
}
 
OSSIA_EXPORT void reset(expression_base& e);
inline void reset(const expression_ptr& e)
{
  return reset(*e);
}
 
OSSIA_EXPORT bool operator==(const expression_base& lhs, const expression_base& rhs);
OSSIA_EXPORT bool operator!=(const expression_base& lhs, const expression_base& rhs);
 
OSSIA_EXPORT expression_callback_iterator
add_callback(expression_base&, expression_result_callback);
 
OSSIA_EXPORT void remove_callback(expression_base&, expression_callback_iterator);
 
OSSIA_EXPORT std::size_t callback_count(expression_base&);
 
OSSIA_EXPORT const expression_base& expression_true();
 
OSSIA_EXPORT const expression_base& expression_false();
 
inline expression_ptr make_expression_true()
{
  return std::make_unique<expression_base>(ossia::in_place_type<expression_bool>, true);
}
 
inline bool is_expression_true(ossia::expression& e) noexcept
{
  const auto p = e.target<expression_bool>();
  return p && p->evaluate();
}
 
inline expression_ptr make_expression_false()
{
  return std::make_unique<expression_base>(ossia::in_place_type<expression_bool>, false);
}
 
template <typename... Args>
expression_ptr make_expression_atom(Args&&... args)
{
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_atom>, std::forward<Args>(args)...);
}
OSSIA_EXPORT
expression_ptr make_expression_atom(
    const ossia::expressions::expression_atom::val_t& lhs,
    ossia::expressions::comparator c,
    const ossia::expressions::expression_atom::val_t& rhs);
OSSIA_EXPORT
expression_ptr make_expression_atom(
    ossia::expressions::expression_atom::val_t&& lhs, ossia::expressions::comparator c,
    ossia::expressions::expression_atom::val_t&& rhs);
 
template <typename... Args>
expression_ptr make_expression_bool(Args&&... args)
{
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_bool>, std::forward<Args>(args)...);
}
 
template <typename... Args>
expression_ptr make_expression_composition(Args&&... args)
{
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_composition>, std::forward<Args>(args)...);
}
 
template <typename... Args>
expression_ptr make_expression_not(Args&&... args)
{
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_not>, std::forward<Args>(args)...);
}
 
template <typename... Args>
expression_ptr make_expression_pulse(Args&&... args)
{
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_pulse>, std::forward<Args>(args)...);
}
 
template <typename T, typename... Args>
expression_ptr make_expression_generic(Args&&... args)
{
  static_assert(
      std::is_base_of<expression_generic_base, T>::value,
      "Must inherit from expression_generic_base");
 
  return std::make_unique<expression_base>(
      ossia::in_place_type<expression_generic>,
      std::make_unique<T>(std::forward<Args>(args)...));
}
}