Module swim.recon
Package swim.recon

Class ReconParser<I,V>

Direct Known Subclasses:

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)