eu.bandm.tools.ramus.runtime2

Class Expression<D,T,A>

java.lang.Object

eu.bandm.tools.ramus.runtime2.AbstractExpression<D,T,A>

eu.bandm.tools.ramus.runtime2.Expression<D,T,A>

public class Expression<D,T,A>
extends AbstractExpression<D,T,A>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Expression.Result<D,T,A>

Constructor Summary

Constructors

Constructor and Description
Expression(Parser<D,T> syntax, Data.View<A> semantics)

Method Summary

Modifier and Type	Method and Description
static <D,T,A> Expression<D,T,A>	access(Class<A> type, Object key)
Expression<D,T,A>	append(Parser<D,T> suffix)
Expression<D,T,A>	append(T... prefix)
Expression<D,T,A>	append(T suffix)
Expression<D,T,A>	assigning(Object key)
static <D,T,A> Expression<D,T,A>	choice(Expression<D,T,? extends A>... alts)
static <D,T,A> Expression<D,T,A>	constant(Parser<D,T> syntax, A value)
static <D,T,A> Expression<D,T,A>	constant(T type, A value)
static <D,T,A> Expression<D,T,A>	constant(T type, String text, A value)
static <D,T,A> Expression<D,T,A>	constantEpsilon(A value)
static <D,T> Expression<D,T,Content<D,T>>	content(Parser<D,T> syntax)
static <D,T> Expression<D,T,Content<D,T>>	content(T... types)
static <D,T,A> Expression<D,T,A>	counit(A value)
static <D,T,A> Expression<D,T,A>	fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)
Expression<D,T,A>	guard(Predicate<? super A> condition, Function<? super A,List<SimpleMessage<D>>> error)
static <D,T,A> Expression<D,T,A>	ifThenElse(T type, Expression<D,T,? extends A> thenBranch, Expression<D,T,? extends A> elseBranch)
static <D,T,A> Expression<D,T,A>	lookahead(Map<T,Expression<D,T,? extends A>> map)
static <D,T,A> Expression<D,T,A>	lookup(Class<A> type, Map<T,? extends A> model)
static <D,T,A> Expression<D,T,A>	lookup(Map<T,? extends A> model)
<B> Expression<D,T,B>	map(Function<? super A,? extends B> fun)
<B> Expression<D,T,Map.Entry<A,B>>	mapsTo(Expression<D,T,B> other)
Expression<D,T,A>	mapSyntax(Function<? super Parser<D,T>,? extends Parser<D,T>> fun)
Expression<D,T,Optional<A>>	optional(Parser.Pragma... pragmas)
Expression<D,T,Optional<A>>	optional(T defaultType)
Expression<D,T,A>	orElse(A defaultValue, Parser.Pragma... pragmas)
Expression<D,T,A>	orElse(Expression<D,T,A> other)
Expression<D,T,A>	orElseGet(Supplier<? extends A> defaultValue, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	plus(Parser.Pragma... pragmas)
Expression<D,T,List<A>>	plus(Parser<D,T> sep, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	plus(T sep, Parser.Pragma... pragmas)
Expression<D,T,A>	prepend(Parser<D,T> prefix)
Expression<D,T,A>	prepend(T... suffix)
Expression<D,T,A>	prepend(T prefix)
Expression.Result<D,T,A>	process(Parser.Input<D,T> in)
Expression.Result<D,T,A>	process(Supplier<? extends Parser.Token<D,T>> in)
Expression<D,T,List<A>>	star(Parser.Pragma... pragmas)
Expression<D,T,List<A>>	star(Parser<D,T> sep, Parser.Pragma... pragmas)
Expression<D,T,List<A>>	star(T sep, Parser.Pragma... pragmas)
String	toString()
static <D,T> Expression<D,T,T>	type(T... types)
static <D,T> Expression<D,T,Void>	unit()
static <D,T> Expression<D,T,Void>	unit(Parser<D,T> syntax)
static <D,T> Expression<D,T,Void>	unit(T... types)
Expression<D,T,A>	withScope(Map<Object,? extends Data> initializers)
Expression<D,T,A>	wrap(Parser<D,T> prefix, Parser<D,T> suffix)
Expression<D,T,A>	wrap(T prefix, T suffix)

Methods inherited from class eu.bandm.tools.ramus.runtime2.AbstractExpression

assign, assign, getProjection, getSemantics, getSyntax

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Expression

public Expression(Parser<D,T> syntax,
                  Data.View<A> semantics)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

content

public static <D,T> Expression<D,T,Content<D,T>> content(Parser<D,T> syntax)

content

@SafeVarargs
public static <D,T> Expression<D,T,Content<D,T>> content(T... types)

type

@SafeVarargs
public static <D,T> Expression<D,T,T> type(T... types)

map

public <B> Expression<D,T,B> map(Function<? super A,? extends B> fun)

prepend

public Expression<D,T,A> prepend(Parser<D,T> prefix)

prepend

public Expression<D,T,A> prepend(T prefix)

append

public Expression<D,T,A> append(Parser<D,T> suffix)

append

public Expression<D,T,A> append(T suffix)

prepend

@SafeVarargs
public final Expression<D,T,A> prepend(T... suffix)

append

@SafeVarargs
public final Expression<D,T,A> append(T... prefix)

wrap

public Expression<D,T,A> wrap(Parser<D,T> prefix,
                              Parser<D,T> suffix)

wrap

public Expression<D,T,A> wrap(T prefix,
                              T suffix)

orElse

public Expression<D,T,A> orElse(A defaultValue,
                                Parser.Pragma... pragmas)

orElseGet

public Expression<D,T,A> orElseGet(Supplier<? extends A> defaultValue,
                                   Parser.Pragma... pragmas)

optional

public Expression<D,T,Optional<A>> optional(T defaultType)

optional

public Expression<D,T,Optional<A>> optional(Parser.Pragma... pragmas)

star

public Expression<D,T,List<A>> star(Parser.Pragma... pragmas)

star

public Expression<D,T,List<A>> star(Parser<D,T> sep,
                                    Parser.Pragma... pragmas)

star

public Expression<D,T,List<A>> star(T sep,
                                    Parser.Pragma... pragmas)

plus

public Expression<D,T,List<A>> plus(Parser.Pragma... pragmas)

plus

public Expression<D,T,List<A>> plus(Parser<D,T> sep,
                                    Parser.Pragma... pragmas)

plus

public Expression<D,T,List<A>> plus(T sep,
                                    Parser.Pragma... pragmas)

constant

public static <D,T,A> Expression<D,T,A> constant(Parser<D,T> syntax,
                                                 A value)

constant

public static <D,T,A> Expression<D,T,A> constant(T type,
                                                 A value)

constant

public static <D,T,A> Expression<D,T,A> constant(T type,
                                                 String text,
                                                 A value)

constantEpsilon

public static <D,T,A> Expression<D,T,A> constantEpsilon(A value)

choice

@SafeVarargs
public static <D,T,A> Expression<D,T,A> choice(Expression<D,T,? extends A>... alts)

orElse

public Expression<D,T,A> orElse(Expression<D,T,A> other)

lookup

public static <D,T,A> Expression<D,T,A> lookup(Class<A> type,
                                               Map<T,? extends A> model)

lookup

public static <D,T,A> Expression<D,T,A> lookup(Map<T,? extends A> model)

lookahead

public static <D,T,A> Expression<D,T,A> lookahead(Map<T,Expression<D,T,? extends A>> map)

mapsTo

public <B> Expression<D,T,Map.Entry<A,B>> mapsTo(Expression<D,T,B> other)

fix

public static <D,T,A> Expression<D,T,A> fix(Function<Expression<D,T,A>,Expression<D,T,A>> loop)

unit

public static <D,T> Expression<D,T,Void> unit(Parser<D,T> syntax)

unit

@SafeVarargs
public static <D,T> Expression<D,T,Void> unit(T... types)

unit

public static <D,T> Expression<D,T,Void> unit()

counit

public static <D,T,A> Expression<D,T,A> counit(A value)

ifThenElse

public static <D,T,A> Expression<D,T,A> ifThenElse(T type,
                                                   Expression<D,T,? extends A> thenBranch,
                                                   Expression<D,T,? extends A> elseBranch)

access

public static <D,T,A> Expression<D,T,A> access(Class<A> type,
                                               Object key)

assigning

public Expression<D,T,A> assigning(Object key)

mapSyntax

public Expression<D,T,A> mapSyntax(Function<? super Parser<D,T>,? extends Parser<D,T>> fun)

withScope

public Expression<D,T,A> withScope(Map<Object,? extends Data> initializers)

guard

public Expression<D,T,A> guard(Predicate<? super A> condition,
                               Function<? super A,List<SimpleMessage<D>>> error)

process

public Expression.Result<D,T,A> process(Supplier<? extends Parser.Token<D,T>> in)

process

public Expression.Result<D,T,A> process(Parser.Input<D,T> in)