Module swim.recon

Package swim.recon

Class ReconParser<I,V>

java.lang.Object

swim.recon.ReconParser<I,V>

Direct Known Subclasses:

ReconStructureParser

public abstract class ReconParser<I,V>
extends Object

Factory for constructing Recon parsers and parse trees.

Constructor Summary

Constructors

Constructor	Description
ReconParser()

Method Summary

Modifier and Type	Method	Description
abstract V	absent()
abstract V	and(V lhs, V rhs)
abstract I	attr(V key)
abstract I	attr(V key, V value)
abstract V	bitwiseAnd(V lhs, V rhs)
abstract V	bitwiseNot(V rhs)
abstract V	bitwiseOr(V lhs, V rhs)
abstract V	bitwiseXor(V lhs, V rhs)
Parser<V>	blockParser()
abstract V	bool(boolean value)
abstract V	children(V selector)
abstract V	conditional(V ifTerm, V thenTerm, V elseTerm)
abstract Output<V>	dataOutput()
abstract V	descendants(V selector)
abstract V	divide(V lhs, V rhs)
abstract V	eq(V lhs, V rhs)
abstract V	extant()
abstract V	filter(V selector, V predicate)
abstract V	ge(V lhs, V rhs)
abstract V	get(V selector, V key)
abstract V	getAttr(V selector, V key)
abstract I	getItem(V selector, V index)
abstract V	gt(V lhs, V rhs)
abstract V	ident(V value)
abstract V	invoke(V func, V args)
abstract boolean	isDistinct(V value)
abstract I	item(V value)
abstract V	keys(V selector)
abstract V	lambda(V bindings, V template)
abstract V	le(V lhs, V rhs)
abstract V	lt(V lhs, V rhs)
abstract V	minus(V lhs, V rhs)
abstract V	modulo(V lhs, V rhs)
abstract V	ne(V lhs, V rhs)
abstract V	negative(V rhs)
abstract V	not(V rhs)
abstract V	num(double value)
abstract V	num(float value)
abstract V	num(int value)
abstract V	num(long value)
abstract V	num(String value)
abstract V	num(BigInteger value)
abstract V	or(V lhs, V rhs)
Parser<V>	parseAdditiveOperator(Input input, Builder<I,V> builder)
Parser<V>	parseAndOperator(Input input, Builder<I,V> builder)
Parser<I>	parseAttr(Input input)
Parser<V>	parseAttrExpression(Input input, Builder<I,V> builder)
Parser<V>	parseBitwiseAndOperator(Input input, Builder<I,V> builder)
Parser<V>	parseBitwiseOrOperator(Input input, Builder<I,V> builder)
Parser<V>	parseBitwiseXorOperator(Input input, Builder<I,V> builder)
Parser<V>	parseBlock(Input input)
Parser<V>	parseBlockExpression(Input input)
Parser<V>	parseBlockExpression(Input input, Builder<I,V> builder)
Parser<V>	parseBlockItem(Input input)
V	parseBlockString(String string)
Parser<V>	parseComparisonOperator(Input input, Builder<I,V> builder)
Parser<V>	parseConditionalOperator(Input input, Builder<I,V> builder)
Parser<V>	parseData(Input input)
Parser<V>	parseIdent(Input input)
Parser<V>	parseInlineItem(Input input)
Parser<V>	parseInteger(Input input)
Parser<V>	parseInvokeOperator(Input input, Builder<I,V> builder)
Parser<V>	parseLambdaFunc(Input input, Builder<I,V> builder)
Parser<V>	parseLiteral(Input input, Builder<I,V> builder)
Parser<V>	parseMarkup(Input input)
Parser<V>	parseMarkup(Input input, Builder<I,V> builder)
Parser<V>	parseMultiplicativeOperator(Input input, Builder<I,V> builder)
Parser<V>	parseNumber(Input input)
V	parseNumberString(String string)
Parser<V>	parseOrOperator(Input input, Builder<I,V> builder)
Parser<V>	parsePrefixOperator(Input input, Builder<I,V> builder)
Parser<V>	parsePrimary(Input input, Builder<I,V> builder)
Parser<V>	parseRawString(Input input)
Parser<V>	parseRecord(Input input)
Parser<V>	parseRecord(Input input, Builder<I,V> builder)
Parser<V>	parseSelector(Input input)
Parser<V>	parseSelector(Input input, Builder<I,V> builder)
Parser<V>	parseString(Input input)
abstract V	plus(V lhs, V rhs)
abstract V	positive(V rhs)
abstract Builder<I,V>	recordBuilder()
abstract V	selector()
abstract I	slot(V key)
abstract I	slot(V key, V value)
abstract Output<V>	textOutput()
abstract V	times(V lhs, V rhs)
abstract V	uint32(int value)
abstract V	uint64(long value)
abstract V	value(I item)
abstract Builder<I,V>	valueBuilder()
abstract V	values(V selector)

Methods inherited from class java.lang.Object

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

Constructor Detail

ReconParser

public ReconParser()

Method Detail

isDistinct

public abstract boolean isDistinct(V value)

item

public abstract I item(V value)

value

public abstract V value(I item)

attr

public abstract I attr(V key,
                       V value)

attr

public abstract I attr(V key)

slot

public abstract I slot(V key,
                       V value)

slot

public abstract I slot(V key)

valueBuilder

public abstract Builder<I,V> valueBuilder()

recordBuilder

public abstract Builder<I,V> recordBuilder()

dataOutput

public abstract Output<V> dataOutput()

textOutput

public abstract Output<V> textOutput()

ident

public abstract V ident(V value)

num

public abstract V num(int value)

num

public abstract V num(long value)

num

public abstract V num(float value)

num

public abstract V num(double value)

num

public abstract V num(BigInteger value)

num

public abstract V num(String value)

uint32

public abstract V uint32(int value)

uint64

public abstract V uint64(long value)

bool

public abstract V bool(boolean value)

selector

public abstract V selector()

extant

public abstract V extant()

absent

public abstract V absent()

conditional

public abstract V conditional(V ifTerm,
                              V thenTerm,
                              V elseTerm)

or

public abstract V or(V lhs,
                     V rhs)

and

public abstract V and(V lhs,
                      V rhs)

bitwiseOr

public abstract V bitwiseOr(V lhs,
                            V rhs)

bitwiseXor

public abstract V bitwiseXor(V lhs,
                             V rhs)

bitwiseAnd

public abstract V bitwiseAnd(V lhs,
                             V rhs)

lt

public abstract V lt(V lhs,
                     V rhs)

le

public abstract V le(V lhs,
                     V rhs)

eq

public abstract V eq(V lhs,
                     V rhs)

ne

public abstract V ne(V lhs,
                     V rhs)

ge

public abstract V ge(V lhs,
                     V rhs)

gt

public abstract V gt(V lhs,
                     V rhs)

plus

public abstract V plus(V lhs,
                       V rhs)

minus

public abstract V minus(V lhs,
                        V rhs)

times

public abstract V times(V lhs,
                        V rhs)

divide

public abstract V divide(V lhs,
                         V rhs)

modulo

public abstract V modulo(V lhs,
                         V rhs)

not

public abstract V not(V rhs)

bitwiseNot

public abstract V bitwiseNot(V rhs)

negative

public abstract V negative(V rhs)

positive

public abstract V positive(V rhs)

invoke

public abstract V invoke(V func,
                         V args)

lambda

public abstract V lambda(V bindings,
                         V template)

get

public abstract V get(V selector,
                      V key)

getAttr

public abstract V getAttr(V selector,
                          V key)

getItem

public abstract I getItem(V selector,
                          V index)

children

public abstract V children(V selector)

descendants

public abstract V descendants(V selector)

keys

public abstract V keys(V selector)

values

public abstract V values(V selector)

filter

public abstract V filter(V selector,
                         V predicate)

parseBlock

public Parser<V> parseBlock(Input input)

parseAttr

public Parser<I> parseAttr(Input input)

parseBlockItem

public Parser<V> parseBlockItem(Input input)

parseInlineItem

public Parser<V> parseInlineItem(Input input)

parseRecord

public Parser<V> parseRecord(Input input,
                             Builder<I,V> builder)

parseRecord

public Parser<V> parseRecord(Input input)

parseMarkup

public Parser<V> parseMarkup(Input input,
                             Builder<I,V> builder)

parseMarkup

public Parser<V> parseMarkup(Input input)

parseData

public Parser<V> parseData(Input input)

parseIdent

public Parser<V> parseIdent(Input input)

parseString

public Parser<V> parseString(Input input)

parseRawString

public Parser<V> parseRawString(Input input)

parseNumber

public Parser<V> parseNumber(Input input)

parseInteger

public Parser<V> parseInteger(Input input)

parseBlockExpression

public Parser<V> parseBlockExpression(Input input,
                                      Builder<I,V> builder)

parseBlockExpression

public Parser<V> parseBlockExpression(Input input)

parseLambdaFunc

public Parser<V> parseLambdaFunc(Input input,
                                 Builder<I,V> builder)

parseConditionalOperator

public Parser<V> parseConditionalOperator(Input input,
                                          Builder<I,V> builder)

parseOrOperator

public Parser<V> parseOrOperator(Input input,
                                 Builder<I,V> builder)

parseAndOperator

public Parser<V> parseAndOperator(Input input,
                                  Builder<I,V> builder)

parseBitwiseOrOperator

public Parser<V> parseBitwiseOrOperator(Input input,
                                        Builder<I,V> builder)

parseBitwiseXorOperator

public Parser<V> parseBitwiseXorOperator(Input input,
                                         Builder<I,V> builder)

parseBitwiseAndOperator

public Parser<V> parseBitwiseAndOperator(Input input,
                                         Builder<I,V> builder)

parseComparisonOperator

public Parser<V> parseComparisonOperator(Input input,
                                         Builder<I,V> builder)

parseAttrExpression

public Parser<V> parseAttrExpression(Input input,
                                     Builder<I,V> builder)

parseAdditiveOperator

public Parser<V> parseAdditiveOperator(Input input,
                                       Builder<I,V> builder)

parseMultiplicativeOperator

public Parser<V> parseMultiplicativeOperator(Input input,
                                             Builder<I,V> builder)

parsePrefixOperator

public Parser<V> parsePrefixOperator(Input input,
                                     Builder<I,V> builder)

parseInvokeOperator

public Parser<V> parseInvokeOperator(Input input,
                                     Builder<I,V> builder)

parsePrimary

public Parser<V> parsePrimary(Input input,
                              Builder<I,V> builder)

parseLiteral

public Parser<V> parseLiteral(Input input,
                              Builder<I,V> builder)

parseSelector

public Parser<V> parseSelector(Input input,
                               Builder<I,V> builder)

parseSelector

public Parser<V> parseSelector(Input input)

blockParser

public Parser<V> blockParser()

parseBlockString

public V parseBlockString(String string)

parseNumberString

public V parseNumberString(String string)