requirement.hpp File Reference

#include <asmgrader/api/asm_function.hpp>
#include <asmgrader/api/asm_symbol.hpp>
#include <asmgrader/api/decomposer.hpp>
#include <asmgrader/api/expression_inspection.hpp>
#include <asmgrader/api/stringize.hpp>
#include <asmgrader/common/error_types.hpp>
#include <asmgrader/common/formatters/unknown.hpp>
#include <asmgrader/common/static_string.hpp>
#include <asmgrader/common/to_static_range.hpp>
#include <asmgrader/logging.hpp>
#include <asmgrader/meta/concepts.hpp>
#include <boost/mp11/detail/mp_list.hpp>
#include <boost/mp11/detail/mp_map_find.hpp>
#include <boost/mp11/list.hpp>
#include <boost/mp11/map.hpp>
#include <boost/type_index.hpp>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <gsl/util>
#include <libassert/assert.hpp>
#include <range/v3/action/take_while.hpp>
#include <range/v3/algorithm/any_of.hpp>
#include <range/v3/algorithm/contains.hpp>
#include <range/v3/algorithm/find.hpp>
#include <range/v3/algorithm/find_if.hpp>
#include <range/v3/algorithm/find_if_not.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/drop_while.hpp>
#include <range/v3/view/split.hpp>
#include <range/v3/view/split_when.hpp>
#include <range/v3/view/take_while.hpp>
#include <array>
#include <concepts>
#include <cstddef>
#include <functional>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
#include <meta/meta.hpp>

Include dependency graph for requirement.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	asmgrader::exprs::NAryOp< OpFn, Rep, Args >
struct	asmgrader::exprs::detail::MapKeyT< Str >
struct	asmgrader::exprs::ExpressionRepr
	Representation of an expression with all components stringized. More...
struct	asmgrader::exprs::ExpressionRepr::Repr
struct	asmgrader::exprs::ExpressionRepr::Value
struct	asmgrader::exprs::ExpressionRepr::Operator
	The str field is the representation of the operator (e.g., '+', '!='). More...
class	asmgrader::Requirement< Op >

Namespaces
namespace	asmgrader
namespace	asmgrader::exprs
	Types and other utilities for representing expressions used in REQUIRE* statements.
namespace	asmgrader::exprs::detail

Concepts
concept	asmgrader::exprs::Operator

Typedefs
template<typename Args >
using	asmgrader::exprs::Noop = NAryOp<std::identity, "", Args>
template<typename Arg >
using	asmgrader::exprs::LogicalNot = NAryOp<std::logical_not<>, "!", Arg>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::Equal = NAryOp<std::equal_to<>, "==", Lhs, Rhs>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::NotEqual = NAryOp<std::not_equal_to<>, "!=", Lhs, Rhs>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::Less = NAryOp<std::less<>, "<", Lhs, Rhs>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::LessEqual = NAryOp<std::less_equal<>, "<=", Lhs, Rhs>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::Greater = NAryOp<std::greater<>, ">", Lhs, Rhs>
template<typename Lhs , typename Rhs >
using	asmgrader::exprs::GreaterEqual = NAryOp<std::greater_equal<>, ">=", Lhs, Rhs>
template<typename T , typename U >
using	asmgrader::exprs::detail::StrToOpTMap
template<StaticString OpStr, typename T , typename U >
using	asmgrader::exprs::OpStrToType = boost::mp11::mp_second<boost::mp11::mp_map_find<detail::StrToOpTMap<T, U>, detail::MapKeyT<OpStr>>>

Enumerations
enum class	asmgrader::exprs::ArityKind { asmgrader::exprs::Nullary = 0 , asmgrader::exprs::Unary , asmgrader::exprs::Binary , asmgrader::exprs::Ternary }

Functions
template<template< typename... > typename Op, typename... Args>
constexpr auto	asmgrader::exprs::make (std::array< inspection::Tokenizer<>, sizeof...(Args)> arg_tokens, Args &&... args)
	For argument deduction purposes.
template<StaticString OpStr, typename T >
	asmgrader::Requirement (DecomposedExpr< OpStr, T > &&, const inspection::Tokenizer<> &, std::string) -> Requirement< exprs::Noop< T > >
	Deduction guide for a single type decomposition expr.
template<StaticString OpStr, typename T , typename U >
	asmgrader::Requirement (DecomposedExpr< OpStr, T, U > &&, const inspection::Tokenizer<> &, std::string) -> Requirement< exprs::OpStrToType< OpStr, T, U > >
	Deduction guide for a binary type decomposition expr.