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)
swim.codec.Parser<V>	blockParser()
abstract V	bool(boolean value)
abstract V	children(V selector)
abstract V	conditional(V ifTerm, V thenTerm, V elseTerm)
abstract swim.codec.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)
swim.codec.Parser<V>	parseAdditiveOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseAndOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<I>	parseAttr(swim.codec.Input input)
swim.codec.Parser<V>	parseAttrExpression(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseBitwiseAndOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseBitwiseOrOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseBitwiseXorOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseBlock(swim.codec.Input input)
swim.codec.Parser<V>	parseBlockExpression(swim.codec.Input input)
swim.codec.Parser<V>	parseBlockExpression(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseBlockItem(swim.codec.Input input)
V	parseBlockString(String string)
swim.codec.Parser<V>	parseComparisonOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseConditionalOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseData(swim.codec.Input input)
swim.codec.Parser<V>	parseIdent(swim.codec.Input input)
swim.codec.Parser<V>	parseInlineItem(swim.codec.Input input)
swim.codec.Parser<V>	parseInteger(swim.codec.Input input)
swim.codec.Parser<V>	parseInvokeOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseLambdaFunc(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseLiteral(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseMarkup(swim.codec.Input input)
swim.codec.Parser<V>	parseMarkup(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseMultiplicativeOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseNumber(swim.codec.Input input)
V	parseNumberString(String string)
swim.codec.Parser<V>	parseOrOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parsePrefixOperator(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parsePrimary(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseRawString(swim.codec.Input input)
swim.codec.Parser<V>	parseRecord(swim.codec.Input input)
swim.codec.Parser<V>	parseRecord(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseSelector(swim.codec.Input input)
swim.codec.Parser<V>	parseSelector(swim.codec.Input input, swim.util.Builder<I,V> builder)
swim.codec.Parser<V>	parseString(swim.codec.Input input)
abstract V	plus(V lhs, V rhs)
abstract V	positive(V rhs)
abstract swim.util.Builder<I,V>	recordBuilder()
abstract V	selector()
abstract I	slot(V key)
abstract I	slot(V key, V value)
abstract swim.codec.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 swim.util.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 swim.util.Builder<I,V> valueBuilder()

recordBuilder

public abstract swim.util.Builder<I,V> recordBuilder()

dataOutput

public abstract swim.codec.Output<V> dataOutput()

textOutput

public abstract swim.codec.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 swim.codec.Parser<V> parseBlock(swim.codec.Input input)

parseAttr

public swim.codec.Parser<I> parseAttr(swim.codec.Input input)

parseBlockItem

public swim.codec.Parser<V> parseBlockItem(swim.codec.Input input)

parseInlineItem

public swim.codec.Parser<V> parseInlineItem(swim.codec.Input input)

parseRecord

public swim.codec.Parser<V> parseRecord(swim.codec.Input input,
                                        swim.util.Builder<I,V> builder)

parseRecord

public swim.codec.Parser<V> parseRecord(swim.codec.Input input)

parseMarkup

public swim.codec.Parser<V> parseMarkup(swim.codec.Input input,
                                        swim.util.Builder<I,V> builder)

parseMarkup

public swim.codec.Parser<V> parseMarkup(swim.codec.Input input)

parseData

public swim.codec.Parser<V> parseData(swim.codec.Input input)

parseIdent

public swim.codec.Parser<V> parseIdent(swim.codec.Input input)

parseString

public swim.codec.Parser<V> parseString(swim.codec.Input input)

parseRawString

public swim.codec.Parser<V> parseRawString(swim.codec.Input input)

parseNumber

public swim.codec.Parser<V> parseNumber(swim.codec.Input input)

parseInteger

public swim.codec.Parser<V> parseInteger(swim.codec.Input input)

parseBlockExpression

public swim.codec.Parser<V> parseBlockExpression(swim.codec.Input input,
                                                 swim.util.Builder<I,V> builder)

parseBlockExpression

public swim.codec.Parser<V> parseBlockExpression(swim.codec.Input input)

parseLambdaFunc

public swim.codec.Parser<V> parseLambdaFunc(swim.codec.Input input,
                                            swim.util.Builder<I,V> builder)

parseConditionalOperator

public swim.codec.Parser<V> parseConditionalOperator(swim.codec.Input input,
                                                     swim.util.Builder<I,V> builder)

parseOrOperator

public swim.codec.Parser<V> parseOrOperator(swim.codec.Input input,
                                            swim.util.Builder<I,V> builder)

parseAndOperator

public swim.codec.Parser<V> parseAndOperator(swim.codec.Input input,
                                             swim.util.Builder<I,V> builder)

parseBitwiseOrOperator

public swim.codec.Parser<V> parseBitwiseOrOperator(swim.codec.Input input,
                                                   swim.util.Builder<I,V> builder)

parseBitwiseXorOperator

public swim.codec.Parser<V> parseBitwiseXorOperator(swim.codec.Input input,
                                                    swim.util.Builder<I,V> builder)

parseBitwiseAndOperator

public swim.codec.Parser<V> parseBitwiseAndOperator(swim.codec.Input input,
                                                    swim.util.Builder<I,V> builder)

parseComparisonOperator

public swim.codec.Parser<V> parseComparisonOperator(swim.codec.Input input,
                                                    swim.util.Builder<I,V> builder)

parseAttrExpression

public swim.codec.Parser<V> parseAttrExpression(swim.codec.Input input,
                                                swim.util.Builder<I,V> builder)

parseAdditiveOperator

public swim.codec.Parser<V> parseAdditiveOperator(swim.codec.Input input,
                                                  swim.util.Builder<I,V> builder)

parseMultiplicativeOperator

public swim.codec.Parser<V> parseMultiplicativeOperator(swim.codec.Input input,
                                                        swim.util.Builder<I,V> builder)

parsePrefixOperator

public swim.codec.Parser<V> parsePrefixOperator(swim.codec.Input input,
                                                swim.util.Builder<I,V> builder)

parseInvokeOperator

public swim.codec.Parser<V> parseInvokeOperator(swim.codec.Input input,
                                                swim.util.Builder<I,V> builder)

parsePrimary

public swim.codec.Parser<V> parsePrimary(swim.codec.Input input,
                                         swim.util.Builder<I,V> builder)

parseLiteral

public swim.codec.Parser<V> parseLiteral(swim.codec.Input input,
                                         swim.util.Builder<I,V> builder)

parseSelector

public swim.codec.Parser<V> parseSelector(swim.codec.Input input,
                                          swim.util.Builder<I,V> builder)

parseSelector

public swim.codec.Parser<V> parseSelector(swim.codec.Input input)

blockParser

public swim.codec.Parser<V> blockParser()

parseBlockString

public V parseBlockString(String string)

parseNumberString

public V parseNumberString(String string)