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 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​(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)
      • parseBlockItem

        public Parser<V> parseBlockItem​(Input input)
      • parseInlineItem

        public Parser<V> parseInlineItem​(Input input)
      • parseRecord

        public Parser<V> parseRecord​(Input input)
      • parseMarkup

        public Parser<V> parseMarkup​(Input input)
      • parseString

        public Parser<V> parseString​(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)
      • parseConditionalOperator

        public Parser<V> parseConditionalOperator​(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)
      • parseAdditiveOperator

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

        public Parser<V> parseMultiplicativeOperator​(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)