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 Details

    • ReconParser

      public ReconParser()

  • Method Details

    • 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)